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

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

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

二，ReentrantReadWriteLock读写锁介绍

1，读写锁介绍

  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

  1. \* *ReentrantReadWriteLock* 实现自 *ReadWriteLock* 接口，并在内部定义了锁实现了相关内部类。
  3. \* *Sync*，*FairSync*，*NonfairSync* 三个内部类是对 AQS 的层次扩展，用来扩展加锁的一系列逻辑处理
  5. \* *WriteLock*，*ReadLock* 两个内部类实现自 *Lock* 接口，并通过 *ReentrantReadWriteLock*  创建后对外提供，在应用层进行不同的加锁处理

3，常用API

  1. // 创建读写锁, 通过参数指定公平锁/非公平锁
  2. public ReentrantReadWriteLock();
  3. public ReentrantReadWriteLock(boolean fair);
  4. // 创建读锁
  5. public ReentrantReadWriteLock.ReadLock  readLock()
  6. // 创建写锁
  7. public ReentrantReadWriteLock.WriteLock writeLock();
  8. // 尝试加锁
  9. public boolean tryLock();
  10. public boolean tryLock(long timeout, TimeUnit unit);
  11. // 加锁
  12. public void lock();
  13. public void lockInterruptibly() throws InterruptedException;
  14. // 释放锁
  15. public void unlock();
  17. \* 在上述API中，关于锁操作的一些API，都存在读锁和写锁的区别；其中，在读锁和写锁的处理中，又存在公平锁和非公平锁的区分；
  19. \* 后续源码分析中，读锁和写锁会分别分析，但是公平锁和分公平锁只对非公平锁进行分析，公平锁参考[重入锁][Link 1]

4，ReentrantReadWriteLock 加锁分析

4.1，整体锁状态存储

  1. \* *ReentrantReadWriteLock* 在锁状态存储中，对 Integer 32位进行拆分，使用高16位存储共享锁，使用低16位存储独占锁。所以无论是共享锁的共享次数还是独占锁的重入次数，最高为（*(1 << 16) - 1*）。
  3. // 1 << 16就是1在二进制情况下右移16位结果为
  4. 10000 0000 0000 0000 = 2^16 = 65536
  5. // (1 << 16) - 1也是在二进制下进行减操作
  6. 1111 1111 1111 1111 = 2^16 - 1 = 65535
  8. \* *ReentrantReadWriteLock *在独占锁加锁时，是对低16位进行加1，在获取独占锁的重入次数时，也是对低16位进行与运算以获取结果加锁具体看代码框
  10. // 独占锁state递增
  11. compareAndSetState(c, c + 1)
  12. // 独占锁获取重入次数
  13. // EXCLUSIVE_MASK：常量，最终结果为 (1111 1111 1111 1111)，也就是对应 Integer 的低16位
  14. // 用c和 EXCLUSIVE_MASK 进行与运算，也就是用c的低16位和 EXCLUSIVE_MASK 进行与运算，
  15. // 与运算同1为1，其余为0，所以获取到的结果就是c的低16位表示的数字，然后再默认转换10进制，即为重入数量
  16. static int exclusiveCount(int c) { 
  17.     return c & EXCLUSIVE_MASK; 
  18. }
  19. static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
  20. static final int SHARED_SHIFT   = 16;
  22. // 比如，此时共享为3次，重入为0次，则c的二进制表示为
  23. 0000 0000 0000 0011 0000 0000 0000 0000
  24. // EXCLUSIVE_MASK的二进制表示为
  25. 0000 0000 0000 0000 1111 1111 1111 1111
  26. // 运算结果
  27.     0000 0000 0000 0011 0000 0000 0000 0000
  28. &    0000 0000 0000 0000 1111 1111 1111 1111
  29. -------------------------------------------
  30.     0000 0000 0000 0000 0000 0000 0000 0000 = 0
  32. // 所以此时获取到的独占锁数量为0
  33. // 假设可以获取成功，则对独占锁递增，通过CAS，用c + 1代替 c，此时，c的二进制表示为：
  34. 0000 0000 0000 0011 0000 0000 0000 0001
  35. // 这时候继续计算，获取独占锁的次数，运算如下
  36.     0000 0000 0000 0011 0000 0000 0000 0001
  37. &    0000 0000 0000 0000 1111 1111 1111 1111
  38. -------------------------------------------
  39.     0000 0000 0000 0000 0000 0000 0000 0001 = 1
  41. \* 同样，*ReentrantReadWriteLock *在对共享锁加锁时，是对高16位进行加锁，在获取共享锁次数时，先对 *state* 无符号右移16位，然后直接获取结果，具体过程如代码框
  43. // 加锁成功后，c递增，按照重入逻辑，递增应该为1
  44. // 而此时递增了(1 << SHARED_SHIFT)，也就是二进制下 1 0000 0000 0000 0000
  45. // 除去低16位，也就是刚好在高16位上递增1
  46. compareAndSetState(c, c + SHARED_UNIT)
  47. static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
  48. static final int SHARED_SHIFT   = 16;
  50. // 共享锁获取锁重入次数
  51. // 直接将state无符号右移16位，表示的就是共享锁的重入次数
  52. // 而右移去掉的16位，也就刚好是独占锁表示的低16位
  53. static int sharedCount(int c)    { 
  54.     return c >>> SHARED_SHIFT; 
  55. }
  56. static final int SHARED_SHIFT   = 16;
  58. // 继续举例，比如此时共享次数3，独占次数为3，则state的二进制表示为
  59. 0000 0000 0000 0011 0000 0000 0000 0011
  60. // 无符号右移16位后，高位补0，值如下
  61. 0000 0000 0000 0000 0000 0000 0000 0011 = 3
  63. // 假设此时共享锁获取成功，state加上(1 << SHARED_SHIFT)，如下
  64.     0000 0000 0000 0011 0000 0000 0000 0011
  65. +    0000 0000 0000 0001 0000 0000 0000 0000
  66. -------------------------------------------
  67.     0000 0000 0000 0100 0000 0000 0000 0000
  68. // 此时继续获取数量，对state无符号右移16位，结果如下
  69. 0000 0000 0000 0000 0000 0000 0000 0100 = 4

5，功能DEMO

  1. package com.gupao.concurrent;
  3. import java.util.concurrent.locks.ReentrantReadWriteLock;
  5. /**
  6.  * @author pj_zhang
  7.  * @create 2019-10-19 12:37
  8.  **/
  9. public class ReadAndWriteLockTest {
  11.     private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
  13.     private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
  15.     private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
  17.     public static void main(String[] args) throws InterruptedException {
  18.         testReadAndWriteLock();
  19.     }
  21.     public static void testWriteAndReadLock() throws InterruptedException {
  22.         new Thread(() -> {
  23.             System.out.println("开始获取锁。。。");
  24.             // 先获取写锁后获取读锁
  25.             // 读锁会顺利获取
  26.             writeLock.lock();
  27.             System.out.println("获取写锁成功。。。");
  28.             readLock.lock();
  29.             System.out.println("获取读锁成功。。。");
  30.             writeLock.unlock();
  31.             System.out.println("释放读锁成功。。。");
  32.             readLock.unlock();
  33.             System.out.println("释放写锁成功");
  34.         }, "READ_AND_WRITE").start();
  35.     }
  37.     public static void testReadAndWriteLock() throws InterruptedException {
  38.         new Thread(() -> {
  39.             System.out.println("开始获取锁。。。");
  40.             // 先获取读写再获取写锁
  41.             // 此时已经存在锁，则独占锁获取失败
  42.             readLock.lock();
  43.             System.out.println("获取读锁成功。。。");
  44.             writeLock.lock();
  45.             System.out.println("获取写锁成功。。。");
  46.             writeLock.unlock();
  47.             System.out.println("释放读锁成功。。。");
  48.             readLock.unlock();
  49.             System.out.println("释放写锁成功");
  50.         }, "READ_AND_WRITE").start();
  51.     }
  53.     /**
  54.      * 不同线程测试读写锁
  55.      *
  56.      * @throws InterruptedException
  57.      */
  58.     public static void testLockWithDiffThread() throws InterruptedException {
  59.         // 先启动一个读锁
  60.         new Thread(() -> {
  61.             System.out.println(Thread.currentThread().getName() + "加读锁前执行。。。, time: " + System.currentTimeMillis());
  62.             readLock.lock();
  63.             System.out.println(Thread.currentThread().getName() + "加读锁后执行。。。, time: " + System.currentTimeMillis());
  64.             sleep(1000);
  65.             readLock.unlock();
  66.         }, "READ_1").start();
  67.         Thread.sleep(10);
  68.         // 再一个一个读锁，模拟读锁不阻塞
  69.         new Thread(() -> {
  70.             System.out.println(Thread.currentThread().getName() + "加读锁前执行。。。, time: " + System.currentTimeMillis());
  71.             readLock.lock();
  72.             System.out.println(Thread.currentThread().getName() + "加读锁后执行。。。, time: " + System.currentTimeMillis());
  73.             sleep(1000);
  74.             readLock.unlock();
  75.         }, "READ_2").start();
  76.         Thread.sleep(10);
  77.         // 启动一个写锁，模拟写锁阻塞
  78.         new Thread(() -> {
  79.             System.out.println(Thread.currentThread().getName() + "_加写锁前执行。。。, time: " + System.currentTimeMillis());
  80.             writeLock.lock();
  81.             System.out.println(Thread.currentThread().getName() + "_加写锁后执行。。。, time: " + System.currentTimeMillis());
  82.             sleep(1000);
  83.             writeLock.unlock();
  84.         }, "WRITE").start();
  85.         Thread.sleep(10);
  86.         // 自启动一个读锁，模拟共享锁执行时，阻塞一个写锁，之后再获取读锁，在写锁后执行
  87.         new Thread(() -> {
  88.             System.out.println(Thread.currentThread().getName() + "加读锁前执行。。。, time: " + System.currentTimeMillis());
  89.             readLock.lock();
  90.             System.out.println(Thread.currentThread().getName() + "加读锁后执行。。。, time: " + System.currentTimeMillis());
  91.             sleep(1000);
  92.             readLock.unlock();
  93.         }, "READ_3").start();
  94.     }
  96.     private static void sleep(long millSeconds) {
  97.         try {
  98.             Thread.sleep(millSeconds);
  99.         } catch (InterruptedException e) {
  100.             e.printStackTrace();
  101.         }
  102.     }
  104. }
  106. \* testLockWithDiffThread() 执行结果：
  108.     1）在不同线程间，读锁间共享，不会进行锁竞争，通过CPU调度依次执行
  110.     2）写锁排斥，在尝试获取写锁时，会先判断是否存在线程持有写锁或者读写，如果存在，则添加到AQS同步队列中等待唤醒
  112.     3）写锁等待后，再启动一个读锁，此时因为写锁等待，并且已经对低16位的独占锁标识进行修改，且锁线程与当前线程不一致。则当前读锁线程获取锁失败，依次进入AQS队列等待

20191019135821604.png

  1. \* testReadAndWriteLock 执行结果
  3.     1）在同一线程后，尝试获取两种锁，从打印结果可以看出，线程获取读锁后，再获取写锁时阻塞，等待读锁释放
  5.     2）线程在获取读锁后，对高16进行修改，并设置锁线程为当前线程
  7.     3）线程继续获取写锁，因为高位已经被修改，所以写锁获取失败，等待读锁释放

20191019140900774.png

  1. \* testWriteAndReadLock 执行结果
  3.     1）在同一线程中，尝试获取两种所，从打印结果可以看出，线程获取写锁后，再获取读锁成功
  5.     2）线程获取写锁后，对低16位进行修改，并设置锁线程为当前线程
  7.     3）线程继续获取读锁，虽然判断独占线程已经存在，但是加锁线程表示当前线程，所以线程获取锁成功

20191019141635313.png

三，ReentrantReadWriteLock部分源码分析

1，初始化部分

  1. \* ReentrantReadWriteLock()：调用重载构造器，并传递参数表示默认非公平锁
  3. public ReentrantReadWriteLock() {
  4.     this(false);
  5. }
  7. \* ReentrantReadWriteLock(boolean fair)
  9. public ReentrantReadWriteLock(boolean fair) {
  10.     // 通过入参表示公平锁还是非公平锁
  11.     sync = fair ? new FairSync() : new NonfairSync();
  12.     // 初始化读写锁对象
  13.     readerLock = new ReadLock(this);
  14.     writerLock = new WriteLock(this);
  15. }
  17. \* 初始化读写锁
  19. // 初始化读锁
  20. protected ReadLock(ReentrantReadWriteLock lock) {
  21.     sync = lock.sync;
  22. }
  23. // 初始化写锁
  24. protected WriteLock(ReentrantReadWriteLock lock) {
  25.     sync = lock.sync;
  26. }
  28. \* 获取读写锁
  30. // 获取写锁
  31. public ReentrantReadWriteLock.WriteLock writeLock() { 
  32.     return writerLock; 
  33. }
  34. // 获取读锁
  35. public ReentrantReadWriteLock.ReadLock  readLock()  { 
  36.     return readerLock; 
  37. }

四，ReentrantReadWriteLock.ReadLock源码分析

1，尝试加锁

  1. \* tryLock()：直接通过 *Sync* 尝试加读锁
  3. public boolean tryLock() {
  4.     return sync.tryReadLock();
  5. }
  7. \* tryReadLock()
  9. final boolean tryReadLock() {
  10.     // 获取当前线程
  11.     Thread current = Thread.currentThread();
  12.     // 自旋尝试获取锁，可能存在线程竞争导致的CAS失败问题
  13.     for (;;) {
  14.         // 获取当前的加锁次数，注意此处次数是经过高低位处理后的次数，并不是真实次数，需要进行解析
  15.         int c = getState();
  16.         // exclusiveCount：低16位解析，获取独占锁数量，判断是否存在独占锁
  17.         // getExclusiveOwnerThread：判断当前线程是否是锁线程
  18.         // 所以如果存在独占锁，并且锁线程不是当前线程，则尝试失败
  19.         // 否则当前步骤成功
  20.         if (exclusiveCount(c) != 0 &&
  21.             getExclusiveOwnerThread() != current)
  22.             return false;
  23.         // 高16位解析，获取共享锁数量
  24.         int r = sharedCount(c);
  25.         // 共享锁最大值判断，
  26.         // MAX_COUNT = (1 << SHARED_SHIFT) - 1;
  27.         if (r == MAX_COUNT)
  28.             throw new Error("Maximum lock count exceeded");
  29.         // 按照重入逻辑，如果可以加锁，则是对state+1
  30.         // 但是共享锁是对高16位进行操作，所以应该在高16位的基础上加1，
  31.         // SHARED_UNIT = (1 << SHARED_SHIFT);
  32.         if (compareAndSetState(c, c + SHARED_UNIT)) {
  33.             // r为0，表示当前并没有共享锁进入，则初始化当前线程为头线程
  34.             if (r == 0) {
  35.                 firstReader = current;
  36.                 firstReaderHoldCount = 1;
  37.             // 当前线程重入，则对重入此时递增
  38.             } else if (firstReader == current) {
  39.                 firstReaderHoldCount++;
  40.             } else {
  41.                 // 此处表示获取共享锁的线程不是当前锁线程
  42.                 // 存在新线程尝试获取共享锁，则cachedHoldCounter必定为null
  43.                 HoldCounter rh = cachedHoldCounter;
  44.                 if (rh == null || rh.tid != getThreadId(current))
  45.                     // readHolds集成自ThreadLocal，为每一个新线程分配一个HoldCounter
  46.                     cachedHoldCounter = rh = readHolds.get();
  47.                 // 可能存在其他途径创建线程的HoldCounter，这样在readHolds中可能不存在（个人理解）
  48.                 else if (rh.count == 0)
  49.                     readHolds.set(rh);
  50.                 // 初始化完成后，对count递增，表示线程加锁及重入
  51.                 rh.count++;
  52.             }
  53.             return true;
  54.         }
  55.     }
  56. }
  58. \* readHolds.get()：此处涉及 ThreadLocal 的初始化部分
  60. // ThreadLocalHoldCounter继承自ThreadLocal
  61. // 泛型表示ThreadLocal为每一个线程分配一个 HoldCounter 对象
  62. // 当前类重写了父类的initialValue()方法，并初始化了一个HoldCounter对象
  63. // 表示 ThreadLocalHoldCounter 默认为每一个线程分配一个已经初始化好的对象
  64. // 每一次get时，如果获取不到线程已经存储的信息，则直接返回一个新对象
  65. static final class ThreadLocalHoldCounter extends ThreadLocal<HoldCounter> {
  66.     public HoldCounter initialValue() {
  67.         return new HoldCounter();
  68.     }
  69. }

2，加锁

  1. \* lock()
  3. public void lock() {
  4.     sync.acquireShared(1);
  5. }
  7. public final void acquireShared(int arg) {
  8.     if (tryAcquireShared(arg) < 0)
  9.         doAcquireShared(arg);
  10. }
  12. \* tryAcquireShared(int unused)
  14. protected final int tryAcquireShared(int unused) {
  15.     Thread current = Thread.currentThread();
  16.     int c = getState();
  17.     // 存在写锁，并且不是当前线程获取，则获取锁失败
  18.     // 此处不排除存在写锁，如果存在写锁则写锁为当前线程持有
  19.     if (exclusiveCount(c) != 0 &&
  20.         getExclusiveOwnerThread() != current)
  21.         return -1;
  22.     // readerShouldBlock()：判断是否存在下一个节点，且下一个节点不是共享节点
  23.     int r = sharedCount(c);
  24.     if (!readerShouldBlock() &&
  25.         r < MAX_COUNT &&
  26.         compareAndSetState(c, c + SHARED_UNIT)) {
  27.         // 下面为加锁处理
  28.         if (r == 0) {
  29.             firstReader = current;
  30.             firstReaderHoldCount = 1;
  31.         } else if (firstReader == current) {
  32.             firstReaderHoldCount++;
  33.         } else {
  34.             HoldCounter rh = cachedHoldCounter;
  35.             if (rh == null || rh.tid != getThreadId(current))
  36.                 cachedHoldCounter = rh = readHolds.get();
  37.             else if (rh.count == 0)
  38.                 readHolds.set(rh);
  39.             rh.count++;
  40.         }
  41.         return 1;
  42.     }
  43.     // 继续尝试获取共享锁
  44.     return fullTryAcquireShared(current);
  45. }
  47. \* fullTryAcquireShared(Thread current)
  49. final int fullTryAcquireShared(Thread current) {
  50.     HoldCounter rh = null;
  51.     for (;;) {
  52.         int c = getState();
  53.         // 判断是否独占锁，且不是当前线程
  54.         // 当前线程获取独占锁后，可继续获取共享锁
  55.         if (exclusiveCount(c) != 0) {
  56.             if (getExclusiveOwnerThread() != current)
  57.                 return -1;
  58.         // 存在下一个节点，并且下一个不是共享锁节点，则需要阻塞
  59.         } else if (readerShouldBlock()) {
  60.             // firstReader表示当前线程，说明正在执行中，默认不阻塞
  61.             if (firstReader == current) {
  62.             } else {
  63.                 // 此处判断当前线程是否在执行中，rh.count表示重入
  64.                 // 如果在执行中，则继续可以获取执行，如果不在执行中，则获取失败
  65.                 if (rh == null) {
  66.                     rh = cachedHoldCounter;
  67.                     if (rh == null || rh.tid != getThreadId(current)) {
  68.                         rh = readHolds.get();
  69.                         if (rh.count == 0)
  70.                             readHolds.remove();
  71.                     }
  72.                 }
  73.                 if (rh.count == 0)
  74.                     return -1;
  75.             }
  76.         }
  77.         // 最大值判断
  78.         if (sharedCount(c) == MAX_COUNT)
  79.             throw new Error("Maximum lock count exceeded");
  80.         // 获取锁成功
  81.         if (compareAndSetState(c, c + SHARED_UNIT)) {
  82.             if (sharedCount(c) == 0) {
  83.                 firstReader = current;
  84.                 firstReaderHoldCount = 1;
  85.             } else if (firstReader == current) {
  86.                 firstReaderHoldCount++;
  87.             } else {
  88.                 if (rh == null)
  89.                     rh = cachedHoldCounter;
  90.                 if (rh == null || rh.tid != getThreadId(current))
  91.                     rh = readHolds.get();
  92.                 else if (rh.count == 0)
  93.                     readHolds.set(rh);
  94.                 rh.count++;
  95.                 cachedHoldCounter = rh; // cache for release
  96.             }
  97.             return 1;
  98.         }
  99.     }
  100. }
  102. \* readerShouldBlock()：存在下一个节点，并且下一个节点不是共享节点，返回true，否则返回false
  104. final boolean readerShouldBlock() {
  105.     return apparentlyFirstQueuedIsExclusive();
  106. }
  108. // 此处判断是否存在下一个节点，以及下一个节点是否为共享节点(取反)
  109. final boolean apparentlyFirstQueuedIsExclusive() {
  110.     Node h, s;
  111.     return (h = head) != null &&
  112.         (s = h.next)  != null &&
  113.         !s.isShared()         &&
  114.         s.thread != null;
  115. }

3，释放锁

  1. \* unlock()
  3. public void unlock() {
  4.     sync.releaseShared(1);
  5. }
  7. public final boolean releaseShared(int arg) {
  8.     if (tryReleaseShared(arg)) {
  9.         doReleaseShared();
  10.         return true;
  11.     }
  12.     return false;
  13. }
  15. \* tryReleaseShared(int unused)
  17. protected final boolean tryReleaseShared(int unused) {
  18.     Thread current = Thread.currentThread();
  19.     // 判断当前线程是否firstReader
  20.     // 此处条件判断，主要为了递减线程重入次数，如果可以释放，则对关键标识对象置空，帮助GC，并方便后续操作判断
  21.     if (firstReader == current) {
  22.         // 继续判断firstReaderHoldCount重入次数，如果为1，说明可以彻底释放，重置firstReader
  23.         // 不为1，递减即可
  24.         if (firstReaderHoldCount == 1)
  25.             firstReader = null;
  26.         else
  27.             firstReaderHoldCount--;
  28.     } else {
  29.         // 当前线程不是firstReader，则从readHolds中获取，并判断count重入次数
  30.         HoldCounter rh = cachedHoldCounter;
  31.         if (rh == null || rh.tid != getThreadId(current))
  32.             rh = readHolds.get();
  33.         int count = rh.count;
  34.         // count <=1，同样表示彻底释放，从readHolds中移除
  35.         if (count <= 1) {
  36.             readHolds.remove();
  37.             if (count <= 0)
  38.                 throw unmatchedUnlockException();
  39.         }
  40.         --rh.count;
  41.     }
  42.     for (;;) {
  43.         // 获取共享锁的重入次数，并递减，是否为0标识
  44.         int c = getState();
  45.         int nextc = c - SHARED_UNIT;
  46.         if (compareAndSetState(c, nextc))
  47.             return nextc == 0;
  48.     }
  49. }

五，ReentrantReadWriteLock.WriteLock源码分析

1，尝试加锁

  1. \* tryLock( )
  3. public boolean tryLock( ) {
  4.     return sync.tryWriteLock();
  5. }
  7. \* tryWriteLock()
  9. final boolean tryWriteLock() {
  10.     Thread current = Thread.currentThread();
  11.     int c = getState();
  12.     // c不为0，表示存在独占锁或者共享锁
  13.     if (c != 0) {
  14.         // 获取独占锁重入次数
  15.         int w = exclusiveCount(c);
  16.         // w为0，说明独占锁为空，则表示存在共享锁，获取锁失败
  17.         // w不为0，并且锁线程不是当前线程，说明存在其他线程持有独占锁，获取锁失败
  18.         // 此处证明在同一线程下，获取共享锁后，不可获取独占锁
  19.         if (w == 0 || current != getExclusiveOwnerThread())
  20.             return false;
  21.         if (w == MAX_COUNT)
  22.             throw new Error("Maximum lock count exceeded");
  23.     }
  24.     // CAS设置重入状态，设置成功后，添加锁线程为当前线程
  25.     if (!compareAndSetState(c, c + 1))
  26.         return false;
  27.     setExclusiveOwnerThread(current);
  28.     return true;
  29. }

2，加锁

  1. \* lock()
  3. public void lock() {
  4.     sync.acquire(1);
  5. }
  7. public final void acquire(int arg) {
  8.     if (!tryAcquire(arg) &&
  9.         acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
  10.         selfInterrupt();
  11. }
  13. \* tryAcquire(int acquires)：此处尝试加锁与上一步尝试加锁基本一致，只是加了一步判断
  15. protected final boolean tryAcquire(int acquires) {
  16.     Thread current = Thread.currentThread();
  17.     int c = getState();
  18.     int w = exclusiveCount(c);
  19.     if (c != 0) {
  20.         if (w == 0 || current != getExclusiveOwnerThread())
  21.             return false;
  22.         if (w + exclusiveCount(acquires) > MAX_COUNT)
  23.             throw new Error("Maximum lock count exceeded");
  24.         setState(c + acquires);
  25.         return true;
  26.     }
  27.     // writerShouldBlock：判断写锁是否需要阻塞
  28.     if (writerShouldBlock() ||
  29.         !compareAndSetState(c, c + acquires))
  30.         return false;
  31.     setExclusiveOwnerThread(current);
  32.     return true;
  33. }
  35. \* writerShouldBlock()：该方法在非公平锁中默认返回false，再公平锁实现中，进行了AQS队列存在性校验，保证顺序执行
  37. // 非公平锁
  38. final boolean writerShouldBlock() {
  39.     return false; 
  40. }
  42. // 公平锁
  43. final boolean writerShouldBlock() {
  44.     return hasQueuedPredecessors();
  45. }
  46. public final boolean hasQueuedPredecessors() {
  47.     Node t = tail;
  48.     Node h = head;
  49.     Node s;
  50.     return h != t &&
  51.         ((s = h.next) == null || s.thread != Thread.currentThread());
  52. }

3，释放锁

  1. \* unlock()
  3. public void unlock() {
  4.     sync.release(1);
  5. }
  7. public final boolean release(int arg) {
  8.     if (tryRelease(arg)) {
  9.         Node h = head;
  10.         if (h != null && h.waitStatus != 0)
  11.             unparkSuccessor(h);
  12.         return true;
  13.     }
  14.     return false;
  15. }
  17. \* tryRelease(int releases)
  19. protected final boolean tryRelease(int releases) {
  20.     // 判断当前线程是否锁线程
  21.     if (!isHeldExclusively())
  22.         throw new IllegalMonitorStateException();
  23.     // 获取释放后的独占锁重入次数
  24.     int nextc = getState() - releases;
  25.     boolean free = exclusiveCount(nextc) == 0;
  26.     // 重入次数为0，则释放成功，置空锁线程，
  27.     if (free)
  28.         setExclusiveOwnerThread(null);
  29.     setState(nextc);
  30.     return free;
  31. }

发表评论

表情：
评论列表 （有 0 条评论，105人围观）

还没有评论，来说两句吧...

相关阅读