ReentrantLock

ReentrantLock与synchronized齐名的经典java锁,十分常用。

文章目录

    • ReentrantLock特性:
    • 非公平锁原理
    • ReentrantLock成员变量
    • ReentrantLock内部类
    • ReentrantLock 构造函数
      • lock
      • unlock

ReentrantLock特性:

  • 可重入
  • 可通过构造参数设置时公平锁还是非公平锁
  • 需要明文释放锁,而synchronized是自动释放的
  • 可响应中断
  • 可在获取锁是设置超时时间
  • 通知队列

非公平锁原理

ReentrantLock本身没有直接实现锁,核心逻辑都交由AQS框架完成,内部核心类Sync即直接继承自AbstractQueuedSynchronizer类,
非公平锁模式:

  1. 某个线程加锁时会先尝试直接设置同步状态,成功就退出
  2. 第一步尝试失败后调用AbstractQueuedSynchronizer的acquire方法,
  3. AbstractQueuedSynchronizer的acquire方法中先调用子类tryAcquire方法,当等待队列为空或者队首节点持有线程就是当前线程则cas设置同步状态,
  4. 第三步也没加锁成功就加入CLH队列

公平锁模式:

  1. 直接调用AbstractQueuedSynchronizer的acquire方法
  2. AbstractQueuedSynchronizer的acquire方法中先调用子类tryAcquire方法,发现锁没线程持有就直接尝试cas设置同步状态,若是发现持有线程就是当前线程则将累计信号量,
  3. 第二步没获取到锁就加入CLH队列

对比两种模式可发现非公平模式下,一旦锁空闲了下来,新到来的线程可能会抢在等待队列中线程前面拿到锁,形成“插队”拿锁,还是直接插在了所有线程前面,但等待队列中的线程没有插队的机会,抱怨也没用,仍然是老老实实的按照顺序排队。

ReentrantLock成员变量

private final Sync sync;

ReentrantLock内部只有一个成员变量Sync,作为一个核心内部类,绝大部分方法都直接依赖这个类实现

ReentrantLock内部类

ReentrantLock_第1张图片
ReentrantLock_第2张图片
ReentrantLock内部共3个内部类,其中Sync是一个抽象方法类,继承自AbstractQueuedSynchronizer,类NonFairSync与FairSync均继承自Sync
类Sync关键方法有3个 分别是lock、nonfairTryAcquire、tryRelease,其中lock是抽象方法,放下面介绍,先看nonfairTryAcquire
nonfairTryAcquire如期单词意义,是用来获取同步信号量的,并且是非公平式的,也就是说排队的线程获取顺序不是严格的先到先得,而是谁抢到就是谁的

 //尝试获取释放状态
	protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            //不是当前线程则抛出异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            //信号量恢复0代表持有当前锁的所有线程都已经释放完毕 
            if (c == 0) {
                free = true;
                //执行线程设置null
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }
//非公平式尝试获取同步状态
	final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            //若发现当前没有线程持有锁 则尝试直接设置信号量拿到锁
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                //设置成功后代表获取锁成功 退出
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
               //锁已经被加锁过至少一次 并且加锁的是当前线程则信号量直接加acquires
                int nextc = c + acquires;
                //和小于0表明锁重入次数已经超过上限
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

NonfairSync类负责非公平锁 ,成员函数也很简单 仅有lock与tryAcquire两个,tryAcquire直接调用父类Sync的nonfairTryAcquire方法(这里吐槽下, nonfairTryAcquire感觉本来就应该放到NonfairSync类里面, 偏偏放Sync里面了,还绕了一个弯调用, 作者不知道咋想的 。。。)

 static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
          //先快速尝试获取锁
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
            // 快速尝试失败后 再排队获取
                acquire(1);
        }
        //尝试获取信号量
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

FairSync跟NonfairSync一样也只有两个成员函数lock 与tryAcquire

static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
        //不再快速尝试获取锁 而是直接排队获取
        final void lock() {
            acquire(1);
        }
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
             //发现锁没人持有 并且等待队列是空的或者头结点线程就是当前线程 则cas尝试获取锁,
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
             //锁重入 
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

ReentrantLock 构造函数

  //默认是非公平锁
	public ReentrantLock() {
       sync = new NonfairSync();
   }
   
   //指定是哪种锁
   public ReentrantLock(boolean fair) {
       sync = fair ? new FairSync() : new NonfairSync();
   }

lock

直接调用内部类的lock

	public void lock() {
       sync.lock();
   }

unlock

直接调用内部类的unlock

public void unlock() {
       sync.release(1);
   }

你可能感兴趣的:(java源码)