并发编程学习---ReentrantLock源码解读

目录

• AQS简介
  • AQS同步队列结构
  • AQS获取同步状态的流程图
• ReentrantLock
  • ReentrantLock类图
  • ReentrantLock运用demo
• 公平锁（FairSync）
  • 获取锁的调用过程
  • 公平锁总结
  • 释放锁的调用过程
• 非公平锁（NonfairSync）
  • 获取锁调用过程
• 公平锁和非公平锁差别

1. AQS简介

ReentrantLock内部主要依赖于java同步框架AbstractQuerySynchronizer，类为实现依赖于先进先出 (FIFO) 等待队列的阻塞锁和相关同步器（信号量、事件，等等）提供一个框架，主要就是：维护锁的当前状态和线程等待列表

1.1 AQS同步队列结构

1.2 AQS获取同步状态的流程图

2. ReentrantLock

2.1 ReentrantLock类图

ReentrantLock主要基于AQS实现，有公平锁和非公平锁两种。

2.2 ReentrantLock运用demo

public class ReentrantLockExample {
    int a= 0;
    //默认是非公平锁
    ReentrantLock lock = new ReentrantLock();
    public void writer(){
        //获取锁
        lock.lock();
        a++;
        //释放锁
        lock.unlock();
    }
    public void reader(){
        //获取锁
        lock.lock();
        int i = a;
        //释放锁
        lock.unlock();
    }
}

3. 公平锁（FairSync）

3.1 获取锁的调用过程

第一步： ReentrantLock.lock()

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

第二步： FairSync.lock()

final void lock() {
    acquire(1);
}

第三步：AbstractQueuedSynchronizer.acquire(int arg)

public final void acquire(int arg) {
    // 尝试获取锁，如果获取锁失败，那么将当前线程执行信息，放入到AQS的内部队列中
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 中断当前线程
        selfInterrupt();
}

第四步： FairySync.tryAcquire(int acquires)

protected final boolean tryAcquire(int acquires) {
    // 获取当前线程
    final Thread current = Thread.currentThread();
    // 获取变量state， 这个变量非常重要，全程主要是围绕这个变量来做事
    int c = getState();
    // 当变量state==0 的时候，表示当前锁是空闲的，可以获取
    if (c == 0) { 
        // 判断当前线程是不是等待最久的线程，就是说判断当前线程是不是在等待队列的第二个元素
        // 因为队列head是当前（之前）拥有锁的线程
        // 如果是，则表示等待时间最久 , 返回false , 表示没有线程比它等的更久
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            // 设置当前执行线程（一个内部变量，为了后面的可重入功能）为 “当前线程”
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // state !=0 , 并且当前线程==当前执行器线程（一个内部变量）
    else if (current == getExclusiveOwnerThread()) {
        // 对state赋值， 由此可以看出，ReentrantLock是一个可重入锁，
       // 但是有一点，就是重入多少次，就必须要unlock多少次，以保证最终state==0 
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

公平锁，确保等待最久的线程优先获取锁

public final boolean hasQueuedPredecessors() {
    Node t = tail; // 尾部元素
    Node h = head; // 头部元素
    // 队列为空的情况下也是返回false
    Node s;
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

3.2 公平锁总结

锁的竞争主要是获取state的状态，0表示没有线程占有他，大于0表示已经被占用了。 公平锁的实现在于判断当前线程是否是head的下一个元素，如果是，那么就OK，就是你了。 因为head一般是上一个占有锁的线程所有

3.3 释放锁的调用过程

第一步：ReentrantLock.unlock()

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

第二步：AbstractQueuedSynchronizer.release(int arg)

public final boolean release(int arg) {
    // 修改state值，减一
    if (tryRelease(arg)) {
        Node h = head;
        // 获取他头结点信息 （头部结点，就是当前拥有锁的线程所拥有）
        if (h != null && h.waitStatus != 0)
            // 主要作用是唤醒头结点的下一个结点
            unparkSuccessor(h);
        return true;
    }
    return false;
}
private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

	// 获取它的next结点
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
		// 唤醒
        LockSupport.unpark(s.thread);
}

第三步：Sync.tryRelease(int releases)

protected final boolean tryRelease(int releases) {
    // 减法 
    int c = getState() - releases;
	// 判断是否是执行线程去调用的unLock()
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
		// 当state=0,释放成功（锁已经空闲）
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

4. 非公平锁（NonfairSync）

4.1 获取锁调用过程

第一步：ReentrantLock:lock() 和公平锁一样
第二步：NonfairSync:lock()

final void lock() {
     // 当线程进来之后，会直接判断当前state的值。如果是0 ，他能够直接通过
	// cas操作，设置state的值为1 的话，那么竞争锁成功
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // 上面设置失败的话，那么直接调用acquire方法
        acquire(1);
}

第三步：AbstractQueuedSynchronizer:compareAndSetState(int expect,int update)

如果资源已经被占用

第四步：AbstractQueuedSynchronizer.acquire(int arg)

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

第五步：NonfairSync.tryAcquire(int acquires)

protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

第六步：Sync.nonfairTryAcquire(int acquires)

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()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

5. 公平锁和非公平锁差别

获取锁的时候相差AbstractQueuedSynchronizer.hasQueuedPredecessors()方法的判断，是否需要取等待时间最长的那个队列，释放锁的流程都相同

参考文档：https://blog.csdn.net/u012394095/article/details/80518594

---