并发编程（六）：AQS之读写锁ReentrantReadWriteLock

偏执的太偏执、 2023-06-04 10:58 58阅读 0赞

# 一，AQS源码博文：[并发编程：AbstractQueuedSynchronizer源码分析][AbstractQueuedSynchronizer] #

# 二，ReentrantReadWriteLock读写锁介绍 #

## 1，读写锁介绍 ##

*ReentrantReadWriteLock* 虽然与 *ReentrantLock* 没有直接关系，但是在功能上算是对 *ReentrantLock* 的扩展。在 *ReentrantLock* 重入独占锁的功能上，添加了共享锁的扩展，分别对应 *ReentrantReadWriteLock* 的写锁（*WriteLock*）和读锁（*ReadLock*）。*ReentrantReadWriteLock* 内部定义 *Sync* 类继承自 *AQS* 对加锁方式进行扩展，在读锁写锁获取以及读写锁交叉获取提供了自身机制，以此保证线程同步。*ReentrantReadWriteLock* 在加锁过程中，对 *Integer* 的32位进行分割，以高16位表示共享锁，以低16位表示独占锁。在进行加锁时，通过左移右移以及与运算判断当前加锁状态及重入状态，并进线程进行调度。

## 2，类图 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE5NzYzODg_size_16_color_FFFFFF_t_70][]

\* *ReentrantReadWriteLock* 实现自 *ReadWriteLock* 接口，并在内部定义了锁实现了相关内部类。

\* *Sync*，*FairSync*，*NonfairSync* 三个内部类是对 AQS 的层次扩展，用来扩展加锁的一系列逻辑处理

\* *WriteLock*，*ReadLock* 两个内部类实现自 *Lock* 接口，并通过 *ReentrantReadWriteLock*  创建后对外提供，在应用层进行不同的加锁处理

## 3，常用API ##

// 创建读写锁, 通过参数指定公平锁/非公平锁
    public ReentrantReadWriteLock();
    public ReentrantReadWriteLock(boolean fair);
    // 创建读锁
    public ReentrantReadWriteLock.ReadLock  readLock()
    // 创建写锁
    public ReentrantReadWriteLock.WriteLock writeLock();
    // 尝试加锁
    public boolean tryLock();
    public boolean tryLock(long timeout, TimeUnit unit);
    // 加锁
    public void lock();
    public void lockInterruptibly() throws InterruptedException;
    // 释放锁
    public void unlock();

\* 在上述API中，关于锁操作的一些API，都存在读锁和写锁的区别；其中，在读锁和写锁的处理中，又存在公平锁和非公平锁的区分；

\* 后续源码分析中，读锁和写锁会分别分析，但是公平锁和分公平锁只对非公平锁进行分析，公平锁参考[重入锁][Link 1]

## 4，*ReentrantReadWriteLock* 加锁分析 ##

### 4.1，整体锁状态存储 ###

\* *ReentrantReadWriteLock* 在锁状态存储中，对 Integer 32位进行拆分，使用高16位存储共享锁，使用低16位存储独占锁。所以无论是共享锁的共享次数还是独占锁的重入次数，最高为（*(1 << 16) - 1*）。

// 1 << 16就是1在二进制情况下右移16位结果为
    10000 0000 0000 0000 = 2^16 = 65536
    // (1 << 16) - 1也是在二进制下进行减操作
    1111 1111 1111 1111 = 2^16 - 1 = 65535

\* *ReentrantReadWriteLock *在独占锁加锁时，是对低16位进行加1，在获取独占锁的重入次数时，也是对低16位进行与运算以获取结果加锁具体看代码框

// 独占锁state递增
    compareAndSetState(c, c + 1)
    // 独占锁获取重入次数
    // EXCLUSIVE_MASK：常量，最终结果为 (1111 1111 1111 1111)，也就是对应 Integer 的低16位
    // 用c和 EXCLUSIVE_MASK 进行与运算，也就是用c的低16位和 EXCLUSIVE_MASK 进行与运算，
    // 与运算同1为1，其余为0，所以获取到的结果就是c的低16位表示的数字，然后再默认转换10进制，即为重入数量
    static int exclusiveCount(int c) { 
    	return c & EXCLUSIVE_MASK; 
    }
    static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
    static final int SHARED_SHIFT   = 16;
    
    // 比如，此时共享为3次，重入为0次，则c的二进制表示为
    0000 0000 0000 0011 0000 0000 0000 0000
    // EXCLUSIVE_MASK的二进制表示为
    0000 0000 0000 0000 1111 1111 1111 1111
    // 运算结果
    	0000 0000 0000 0011 0000 0000 0000 0000
    &	0000 0000 0000 0000 1111 1111 1111 1111
    -------------------------------------------
    	0000 0000 0000 0000 0000 0000 0000 0000 = 0
    	
    // 所以此时获取到的独占锁数量为0
    // 假设可以获取成功，则对独占锁递增，通过CAS，用c + 1代替 c，此时，c的二进制表示为：
    0000 0000 0000 0011 0000 0000 0000 0001
    // 这时候继续计算，获取独占锁的次数，运算如下
    	0000 0000 0000 0011 0000 0000 0000 0001
    &	0000 0000 0000 0000 1111 1111 1111 1111
    -------------------------------------------
    	0000 0000 0000 0000 0000 0000 0000 0001 = 1

\* 同样，*ReentrantReadWriteLock *在对共享锁加锁时，是对高16位进行加锁，在获取共享锁次数时，先对 *state* 无符号右移16位，然后直接获取结果，具体过程如代码框

// 加锁成功后，c递增，按照重入逻辑，递增应该为1
    // 而此时递增了(1 << SHARED_SHIFT)，也就是二进制下 1 0000 0000 0000 0000
    // 除去低16位，也就是刚好在高16位上递增1
    compareAndSetState(c, c + SHARED_UNIT)
    static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
    static final int SHARED_SHIFT   = 16;
    
    // 共享锁获取锁重入次数
    // 直接将state无符号右移16位，表示的就是共享锁的重入次数
    // 而右移去掉的16位，也就刚好是独占锁表示的低16位
    static int sharedCount(int c)    { 
    	return c >>> SHARED_SHIFT; 
    }
    static final int SHARED_SHIFT   = 16;
    
    // 继续举例，比如此时共享次数3，独占次数为3，则state的二进制表示为
    0000 0000 0000 0011 0000 0000 0000 0011
    // 无符号右移16位后，高位补0，值如下
    0000 0000 0000 0000 0000 0000 0000 0011 = 3
    
    // 假设此时共享锁获取成功，state加上(1 << SHARED_SHIFT)，如下
    	0000 0000 0000 0011 0000 0000 0000 0011
    +	0000 0000 0000 0001 0000 0000 0000 0000
    -------------------------------------------
    	0000 0000 0000 0100 0000 0000 0000 0000
    // 此时继续获取数量，对state无符号右移16位，结果如下
    0000 0000 0000 0000 0000 0000 0000 0100 = 4

## 5，功能DEMO ##

package com.gupao.concurrent;
    
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /**
     * @author pj_zhang
     * @create 2019-10-19 12:37
     **/
    public class ReadAndWriteLockTest {
    
        private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
    
        private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
    
        private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
    
        public static void main(String[] args) throws InterruptedException {
            testReadAndWriteLock();
        }
    
        public static void testWriteAndReadLock() throws InterruptedException {
            new Thread(() -> {
                System.out.println("开始获取锁。。。");
                // 先获取写锁后获取读锁
                // 读锁会顺利获取
                writeLock.lock();
                System.out.println("获取写锁成功。。。");
                readLock.lock();
                System.out.println("获取读锁成功。。。");
                writeLock.unlock();
                System.out.println("释放读锁成功。。。");
                readLock.unlock();
                System.out.println("释放写锁成功");
            }, "READ_AND_WRITE").start();
        }
    
        public static void testReadAndWriteLock() throws InterruptedException {
            new Thread(() -> {
                System.out.println("开始获取锁。。。");
                // 先获取读写再获取写锁
                // 此时已经存在锁，则独占锁获取失败
                readLock.lock();
                System.out.println("获取读锁成功。。。");
                writeLock.lock();
                System.out.println("获取写锁成功。。。");
                writeLock.unlock();
                System.out.println("释放读锁成功。。。");
                readLock.unlock();
                System.out.println("释放写锁成功");
            }, "READ_AND_WRITE").start();
        }
    
        /**
         * 不同线程测试读写锁
         *
         * @throws InterruptedException
         */
        public static void testLockWithDiffThread() throws InterruptedException {
            // 先启动一个读锁
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "加读锁前执行。。。, time: " + System.currentTimeMillis());
                readLock.lock();
                System.out.println(Thread.currentThread().getName() + "加读锁后执行。。。, time: " + System.currentTimeMillis());
                sleep(1000);
                readLock.unlock();
            }, "READ_1").start();
            Thread.sleep(10);
            // 再一个一个读锁，模拟读锁不阻塞
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "加读锁前执行。。。, time: " + System.currentTimeMillis());
                readLock.lock();
                System.out.println(Thread.currentThread().getName() + "加读锁后执行。。。, time: " + System.currentTimeMillis());
                sleep(1000);
                readLock.unlock();
            }, "READ_2").start();
            Thread.sleep(10);
            // 启动一个写锁，模拟写锁阻塞
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "_加写锁前执行。。。, time: " + System.currentTimeMillis());
                writeLock.lock();
                System.out.println(Thread.currentThread().getName() + "_加写锁后执行。。。, time: " + System.currentTimeMillis());
                sleep(1000);
                writeLock.unlock();
            }, "WRITE").start();
            Thread.sleep(10);
            // 自启动一个读锁，模拟共享锁执行时，阻塞一个写锁，之后再获取读锁，在写锁后执行
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "加读锁前执行。。。, time: " + System.currentTimeMillis());
                readLock.lock();
                System.out.println(Thread.currentThread().getName() + "加读锁后执行。。。, time: " + System.currentTimeMillis());
                sleep(1000);
                readLock.unlock();
            }, "READ_3").start();
        }
    
        private static void sleep(long millSeconds) {
            try {
                Thread.sleep(millSeconds);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
    }

\* testLockWithDiffThread() 执行结果：

1）在不同线程间，读锁间共享，不会进行锁竞争，通过CPU调度依次执行

2）写锁排斥，在尝试获取写锁时，会先判断是否存在线程持有写锁或者读写，如果存在，则添加到AQS同步队列中等待唤醒

3）写锁等待后，再启动一个读锁，此时因为写锁等待，并且已经对低16位的独占锁标识进行修改，且锁线程与当前线程不一致。则当前读锁线程获取锁失败，依次进入AQS队列等待

![20191019135821604.png][]

\* testReadAndWriteLock 执行结果

1）在同一线程后，尝试获取两种锁，从打印结果可以看出，线程获取读锁后，再获取写锁时阻塞，等待读锁释放

2）线程在获取读锁后，对高16进行修改，并设置锁线程为当前线程

3）线程继续获取写锁，因为高位已经被修改，所以写锁获取失败，等待读锁释放

![20191019140900774.png][]

\* testWriteAndReadLock 执行结果

1）在同一线程中，尝试获取两种所，从打印结果可以看出，线程获取写锁后，再获取读锁成功

2）线程获取写锁后，对低16位进行修改，并设置锁线程为当前线程

3）线程继续获取读锁，虽然判断独占线程已经存在，但是加锁线程表示当前线程，所以线程获取锁成功

![20191019141635313.png][]

# 三，ReentrantReadWriteLock部分源码分析 #

## 1，初始化部分 ##

\* ReentrantReadWriteLock()：调用重载构造器，并传递参数表示默认非公平锁

public ReentrantReadWriteLock() {
    	this(false);
    }

\* ReentrantReadWriteLock(boolean fair)

public ReentrantReadWriteLock(boolean fair) {
    	// 通过入参表示公平锁还是非公平锁
    	sync = fair ? new FairSync() : new NonfairSync();
    	// 初始化读写锁对象
    	readerLock = new ReadLock(this);
    	writerLock = new WriteLock(this);
    }

\* 初始化读写锁

// 初始化读锁
    protected ReadLock(ReentrantReadWriteLock lock) {
    	sync = lock.sync;
    }
    // 初始化写锁
    protected WriteLock(ReentrantReadWriteLock lock) {
    	sync = lock.sync;
    }

\* 获取读写锁

// 获取写锁
    public ReentrantReadWriteLock.WriteLock writeLock() { 
    	return writerLock; 
    }
    // 获取读锁
    public ReentrantReadWriteLock.ReadLock  readLock()  { 
    	return readerLock; 
    }

# 四，ReentrantReadWriteLock.ReadLock源码分析 #

## 1，尝试加锁 ##

\* tryLock()：直接通过 *Sync* 尝试加读锁

public boolean tryLock() {
    	return sync.tryReadLock();
    }

\* tryReadLock()

final boolean tryReadLock() {
    	// 获取当前线程
    	Thread current = Thread.currentThread();
    	// 自旋尝试获取锁，可能存在线程竞争导致的CAS失败问题
    	for (;;) {
    		// 获取当前的加锁次数，注意此处次数是经过高低位处理后的次数，并不是真实次数，需要进行解析
    		int c = getState();
    		// exclusiveCount：低16位解析，获取独占锁数量，判断是否存在独占锁
    		// getExclusiveOwnerThread：判断当前线程是否是锁线程
    		// 所以如果存在独占锁，并且锁线程不是当前线程，则尝试失败
    		// 否则当前步骤成功
    		if (exclusiveCount(c) != 0 &&
    			getExclusiveOwnerThread() != current)
    			return false;
    		// 高16位解析，获取共享锁数量
    		int r = sharedCount(c);
    		// 共享锁最大值判断，
    		// MAX_COUNT = (1 << SHARED_SHIFT) - 1;
    		if (r == MAX_COUNT)
    			throw new Error("Maximum lock count exceeded");
    		// 按照重入逻辑，如果可以加锁，则是对state+1
    		// 但是共享锁是对高16位进行操作，所以应该在高16位的基础上加1，
    		// SHARED_UNIT = (1 << SHARED_SHIFT);
    		if (compareAndSetState(c, c + SHARED_UNIT)) {
    			// r为0，表示当前并没有共享锁进入，则初始化当前线程为头线程
    			if (r == 0) {
    				firstReader = current;
    				firstReaderHoldCount = 1;
    			// 当前线程重入，则对重入此时递增
    			} else if (firstReader == current) {
    				firstReaderHoldCount++;
    			} else {
    				// 此处表示获取共享锁的线程不是当前锁线程
    				// 存在新线程尝试获取共享锁，则cachedHoldCounter必定为null
    				HoldCounter rh = cachedHoldCounter;
    				if (rh == null || rh.tid != getThreadId(current))
    					// readHolds集成自ThreadLocal，为每一个新线程分配一个HoldCounter
    					cachedHoldCounter = rh = readHolds.get();
    				// 可能存在其他途径创建线程的HoldCounter，这样在readHolds中可能不存在（个人理解）
    				else if (rh.count == 0)
    					readHolds.set(rh);
    				// 初始化完成后，对count递增，表示线程加锁及重入
    				rh.count++;
    			}
    			return true;
    		}
    	}
    }

\* readHolds.get()：此处涉及 ThreadLocal 的初始化部分

// ThreadLocalHoldCounter继承自ThreadLocal
    // 泛型表示ThreadLocal为每一个线程分配一个 HoldCounter 对象
    // 当前类重写了父类的initialValue()方法，并初始化了一个HoldCounter对象
    // 表示 ThreadLocalHoldCounter 默认为每一个线程分配一个已经初始化好的对象
    // 每一次get时，如果获取不到线程已经存储的信息，则直接返回一个新对象
    static final class ThreadLocalHoldCounter extends ThreadLocal<HoldCounter> {
    	public HoldCounter initialValue() {
    		return new HoldCounter();
    	}
    }

## 2，加锁 ##

\* lock()

public void lock() {
    	sync.acquireShared(1);
    }
    
    public final void acquireShared(int arg) {
    	if (tryAcquireShared(arg) < 0)
    		doAcquireShared(arg);
    }

\* tryAcquireShared(int unused)

protected final int tryAcquireShared(int unused) {
    	Thread current = Thread.currentThread();
    	int c = getState();
    	// 存在写锁，并且不是当前线程获取，则获取锁失败
    	// 此处不排除存在写锁，如果存在写锁则写锁为当前线程持有
    	if (exclusiveCount(c) != 0 &&
    		getExclusiveOwnerThread() != current)
    		return -1;
    	// readerShouldBlock()：判断是否存在下一个节点，且下一个节点不是共享节点
    	int r = sharedCount(c);
    	if (!readerShouldBlock() &&
    		r < MAX_COUNT &&
    		compareAndSetState(c, c + SHARED_UNIT)) {
    		// 下面为加锁处理
    		if (r == 0) {
    			firstReader = current;
    			firstReaderHoldCount = 1;
    		} else if (firstReader == current) {
    			firstReaderHoldCount++;
    		} else {
    			HoldCounter rh = cachedHoldCounter;
    			if (rh == null || rh.tid != getThreadId(current))
    				cachedHoldCounter = rh = readHolds.get();
    			else if (rh.count == 0)
    				readHolds.set(rh);
    			rh.count++;
    		}
    		return 1;
    	}
    	// 继续尝试获取共享锁
    	return fullTryAcquireShared(current);
    }

\* fullTryAcquireShared(Thread current)

final int fullTryAcquireShared(Thread current) {
    	HoldCounter rh = null;
    	for (;;) {
    		int c = getState();
    		// 判断是否独占锁，且不是当前线程
    		// 当前线程获取独占锁后，可继续获取共享锁
    		if (exclusiveCount(c) != 0) {
    			if (getExclusiveOwnerThread() != current)
    				return -1;
    		// 存在下一个节点，并且下一个不是共享锁节点，则需要阻塞
    		} else if (readerShouldBlock()) {
    			// firstReader表示当前线程，说明正在执行中，默认不阻塞
    			if (firstReader == current) {
    			} else {
    				// 此处判断当前线程是否在执行中，rh.count表示重入
    				// 如果在执行中，则继续可以获取执行，如果不在执行中，则获取失败
    				if (rh == null) {
    					rh = cachedHoldCounter;
    					if (rh == null || rh.tid != getThreadId(current)) {
    						rh = readHolds.get();
    						if (rh.count == 0)
    							readHolds.remove();
    					}
    				}
    				if (rh.count == 0)
    					return -1;
    			}
    		}
    		// 最大值判断
    		if (sharedCount(c) == MAX_COUNT)
    			throw new Error("Maximum lock count exceeded");
    		// 获取锁成功
    		if (compareAndSetState(c, c + SHARED_UNIT)) {
    			if (sharedCount(c) == 0) {
    				firstReader = current;
    				firstReaderHoldCount = 1;
    			} else if (firstReader == current) {
    				firstReaderHoldCount++;
    			} else {
    				if (rh == null)
    					rh = cachedHoldCounter;
    				if (rh == null || rh.tid != getThreadId(current))
    					rh = readHolds.get();
    				else if (rh.count == 0)
    					readHolds.set(rh);
    				rh.count++;
    				cachedHoldCounter = rh; // cache for release
    			}
    			return 1;
    		}
    	}
    }

\* readerShouldBlock()：存在下一个节点，并且下一个节点不是共享节点，返回true，否则返回false

final boolean readerShouldBlock() {
    	return apparentlyFirstQueuedIsExclusive();
    }
    
    // 此处判断是否存在下一个节点，以及下一个节点是否为共享节点(取反)
    final boolean apparentlyFirstQueuedIsExclusive() {
    	Node h, s;
    	return (h = head) != null &&
    		(s = h.next)  != null &&
    		!s.isShared()         &&
    		s.thread != null;
    }

## 3，释放锁 ##

\* unlock()

public void unlock() {
    	sync.releaseShared(1);
    }
    
    public final boolean releaseShared(int arg) {
    	if (tryReleaseShared(arg)) {
    		doReleaseShared();
    		return true;
    	}
    	return false;
    }

\* tryReleaseShared(int unused)

protected final boolean tryReleaseShared(int unused) {
    	Thread current = Thread.currentThread();
    	// 判断当前线程是否firstReader
    	// 此处条件判断，主要为了递减线程重入次数，如果可以释放，则对关键标识对象置空，帮助GC，并方便后续操作判断
    	if (firstReader == current) {
    		// 继续判断firstReaderHoldCount重入次数，如果为1，说明可以彻底释放，重置firstReader
    		// 不为1，递减即可
    		if (firstReaderHoldCount == 1)
    			firstReader = null;
    		else
    			firstReaderHoldCount--;
    	} else {
    		// 当前线程不是firstReader，则从readHolds中获取，并判断count重入次数
    		HoldCounter rh = cachedHoldCounter;
    		if (rh == null || rh.tid != getThreadId(current))
    			rh = readHolds.get();
    		int count = rh.count;
    		// count <=1，同样表示彻底释放，从readHolds中移除
    		if (count <= 1) {
    			readHolds.remove();
    			if (count <= 0)
    				throw unmatchedUnlockException();
    		}
    		--rh.count;
    	}
    	for (;;) {
    		// 获取共享锁的重入次数，并递减，是否为0标识
    		int c = getState();
    		int nextc = c - SHARED_UNIT;
    		if (compareAndSetState(c, nextc))
    			return nextc == 0;
    	}
    }

# 五，ReentrantReadWriteLock.WriteLock源码分析 #

## 1，尝试加锁 ##

\* tryLock( )

public boolean tryLock( ) {
    	return sync.tryWriteLock();
    }

\* tryWriteLock()

final boolean tryWriteLock() {
    	Thread current = Thread.currentThread();
    	int c = getState();
    	// c不为0，表示存在独占锁或者共享锁
    	if (c != 0) {
    		// 获取独占锁重入次数
    		int w = exclusiveCount(c);
    		// w为0，说明独占锁为空，则表示存在共享锁，获取锁失败
    		// w不为0，并且锁线程不是当前线程，说明存在其他线程持有独占锁，获取锁失败
    		// 此处证明在同一线程下，获取共享锁后，不可获取独占锁
    		if (w == 0 || current != getExclusiveOwnerThread())
    			return false;
    		if (w == MAX_COUNT)
    			throw new Error("Maximum lock count exceeded");
    	}
    	// CAS设置重入状态，设置成功后，添加锁线程为当前线程
    	if (!compareAndSetState(c, c + 1))
    		return false;
    	setExclusiveOwnerThread(current);
    	return true;
    }

## 2，加锁 ##

\* lock()

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

\* tryAcquire(int acquires)：此处尝试加锁与上一步尝试加锁基本一致，只是加了一步判断

protected final boolean tryAcquire(int acquires) {
    	Thread current = Thread.currentThread();
    	int c = getState();
    	int w = exclusiveCount(c);
    	if (c != 0) {
    		if (w == 0 || current != getExclusiveOwnerThread())
    			return false;
    		if (w + exclusiveCount(acquires) > MAX_COUNT)
    			throw new Error("Maximum lock count exceeded");
    		setState(c + acquires);
    		return true;
    	}
    	// writerShouldBlock：判断写锁是否需要阻塞
    	if (writerShouldBlock() ||
    		!compareAndSetState(c, c + acquires))
    		return false;
    	setExclusiveOwnerThread(current);
    	return true;
    }

\* writerShouldBlock()：该方法在非公平锁中默认返回false，再公平锁实现中，进行了AQS队列存在性校验，保证顺序执行

// 非公平锁
    final boolean writerShouldBlock() {
    	return false; 
    }
    
    // 公平锁
    final boolean writerShouldBlock() {
    	return hasQueuedPredecessors();
    }
    public final boolean hasQueuedPredecessors() {
    	Node t = tail;
    	Node h = head;
    	Node s;
    	return h != t &&
    		((s = h.next) == null || s.thread != Thread.currentThread());
    }

## 3，释放锁 ##

\* unlock()

public void unlock() {
    	sync.release(1);
    }
    
    public final boolean release(int arg) {
    	if (tryRelease(arg)) {
    		Node h = head;
    		if (h != null && h.waitStatus != 0)
    			unparkSuccessor(h);
    		return true;
    	}
    	return false;
    }

\* tryRelease(int releases)

protected final boolean tryRelease(int releases) {
    	// 判断当前线程是否锁线程
    	if (!isHeldExclusively())
    		throw new IllegalMonitorStateException();
    	// 获取释放后的独占锁重入次数
    	int nextc = getState() - releases;
    	boolean free = exclusiveCount(nextc) == 0;
    	// 重入次数为0，则释放成功，置空锁线程，
    	if (free)
    		setExclusiveOwnerThread(null);
    	setState(nextc);
    	return free;
    }

[AbstractQueuedSynchronizer]: https://blog.csdn.net/u011976388/article/details/101717658
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE5NzYzODg_size_16_color_FFFFFF_t_70]: /images/20230601/f7878de0667f44d18bae4064e800ee96.png
[Link 1]: https://blog.csdn.net/u011976388/article/details/102238964
[20191019135821604.png]: /images/20230601/7b573ecabb224f8ea54dce59b3410bbb.png
[20191019140900774.png]: /images/20230601/558d6ba99d5e40dbbc0a81768ea3d41c.png
[20191019141635313.png]: /images/20230601/a256ba327a3d4a1a923a87c074a8b9a3.png