Update Java Notes

Seazean · Seazean · commit 5d4885103b45 · 2021-11-20T15:05:06.000+08:00
diff --git a/Prog.md b/Prog.md
@@ -622,7 +622,7 @@ t.start();
 | public final void suspend() | **挂起（暂停）线程运行** |
 | public final void resume()  | 恢复线程运行             |
 
-所以 Java 中线程的状态是阻塞，很少使用挂起
+
 
 
 
@@ -9289,7 +9289,7 @@ ReentrantReadWriteLock 其**读锁是共享锁，写锁是独占锁**
 
 * **重入时升级不支持**：持有读锁的情况下去获取写锁会导致获取写锁永久等待，需要先释放读，再去获得写
 
-* **重入时降级支持**：持有写锁的情况下去获取读锁
+* **重入时降级支持**：持有写锁的情况下去获取读锁，造成只有当前线程会持有读锁，因为写锁会互斥其他的锁
 
   ```java
   w.lock();
@@ -9357,7 +9357,7 @@ public static void main(String[] args) {
 
 缓存更新时，是先清缓存还是先更新数据库
 
-* 先清缓存：可能造成刚清理缓存还没有更新数据库，线程直接查询了数据库更新缓存
+* 先清缓存：可能造成刚清理缓存还没有更新数据库，线程直接查询了数据库更新过期数据到缓存
 
 * 先更新据库：可能造成刚更新数据库，还没清空缓存就有线程从缓存拿到了旧数据
 
@@ -9375,14 +9375,110 @@ public static void main(String[] args) {
 
 #### 实现原理
 
-##### 加锁原理
+##### 成员属性
 
 读写锁用的是同一个 Sycn 同步器，因此等待队列、state 等也是同一个，原理与 ReentrantLock 加锁相比没有特殊之处，不同是**写锁状态占了 state 的低 16 位，而读锁使用的是 state 的高 16 位**
 
-* t1 w.lock（写锁），成功上锁 state = 0_1
+* 读写锁：
+
+  ```java
+  private final ReentrantReadWriteLock.ReadLock readerLock;		
+  private final ReentrantReadWriteLock.WriteLock writerLock;
+  ```
+
+* 构造方法：默认是非公平锁，可以指定参数创建公平锁
+
+  ```java
+  public ReentrantReadWriteLock(boolean fair) {
+      // true 为公平锁
+      sync = fair ? new FairSync() : new NonfairSync();
+      // 这两个 lock 共享同一个 sync 实例，都是由 ReentrantReadWriteLock 的 sync 提供同步实现
+      readerLock = new ReadLock(this);
+      writerLock = new WriteLock(this);
+  }
+  ```
+
+Sync 类的属性：
+
+* 统计变量：
+
+  ```java
+  // 用来移位
+  static final int SHARED_SHIFT   = 16;
+  // 高16位的1
+  static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
+  // 65535，16个1，代表写锁的最大重入次数
+  static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
+  // 低16位掩码：0b 1111 1111 1111 1111，用来获取写锁重入的次数
+  static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
+  ```
+
+* 获取读写锁的次数：
+
+  ```java
+  // 获取读写锁的读锁分配的总次数
+  static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
+  // 写锁（独占）锁的重入次数
+  static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }
+  ```
+
+* 内部类：
+
+  ```java
+  // 记录读锁线程自己的持有读锁的数量（重入次数），因为 state 高16位记录的是全局范围内所有的读线程获取读锁的总量
+  static final class HoldCounter {
+      int count = 0;
+      // Use id, not reference, to avoid garbage retention
+      final long tid = getThreadId(Thread.currentThread());
+  }
+  // 线程安全的存放线程各自的 HoldCounter 对象
+  static final class ThreadLocalHoldCounter extends ThreadLocal<HoldCounter> {
+      public HoldCounter initialValue() {
+          return new HoldCounter();
+      }
+  }
+  ```
+
+* 内部类实例：
+
+  ```java
+  // 当前线程持有的可重入读锁的数量，计数为 0 时删除
+  private transient ThreadLocalHoldCounter readHolds;
+  // 记录最后一个获取【读锁】线程的 HoldCounter 对象
+  private transient HoldCounter cachedHoldCounter;
+  ```
+
+* 首次获取锁：
+
+  ```java
+  // 第一个获取读锁的线程
+  private transient Thread firstReader = null;
+  // 记录该线程持有的读锁次数（读锁重入次数）
+  private transient int firstReaderHoldCount;
+  ```
+
+* Sync 构造方法：
 
   ```java
-  //lock()  -> sync.acquire(1);
+  Sync() {
+      readHolds = new ThreadLocalHoldCounter();
+      // 确保其他线程的数据可见性，state 是 volatile 修饰的变量，重写该值会将线程本地缓存数据【同步至主存】
+      setState(getState()); 
+  }
+  ```
+
+
+
+***
+
+
+
+##### 加锁原理
+
+* t1 线程：w.lock（**写锁**），成功上锁 state = 0_1
+
+  ```java
+  // lock()  -> sync.acquire(1);
   public void lock() {
       sync.acquire(1);
   }
@@ -9399,20 +9495,22 @@ public static void main(String[] args) {
       int c = getState();
       // 获得低 16 位, 代表写锁的 state 计数
       int w = exclusiveCount(c);
+      // 说明有读锁或者写锁
       if (c != 0) {
-          // c != 0 and w == 0 表示 r != 0，有读锁，读锁不能升级，直接返回false
+          // c != 0 and w == 0 表示有读锁，【读锁不能升级】，直接返回 false
           // w != 0 说明有写锁，写锁的拥有者不是自己，获取失败
           if (w == 0 || current != getExclusiveOwnerThread())
               return false;
-          // 锁重入计数超过低 16 位, 报异常
+          
+          // 执行到这里只有一种情况：【写锁重入】，所以下面几行代码不存在并发
           if (w + exclusiveCount(acquires) > MAX_COUNT)
               throw new Error("Maximum lock count exceeded");
-          // 【写锁重入, 获得锁成功】
+          // 写锁重入, 获得锁成功，没有并发，所以不使用 CAS
           setState(c + acquires);
           return true;
       }
       
-      // c == 0，没有任何锁，判断写锁是否该阻塞，是 false 就尝试获取锁，失败返回 false
+      // c == 0，说明没有任何锁，判断写锁是否该阻塞，是 false 就尝试获取锁，失败返回 false
       if (writerShouldBlock() || !compareAndSetState(c, c + acquires))
           return false;
       // 获得锁成功，设置锁的持有线程为当前线程
@@ -9429,11 +9527,11 @@ public static void main(String[] args) {
   }
   ```
   
-* t2 r.lock（读锁），进入 tryAcquireShared 流程，如果有写锁占据，那么 tryAcquireShared 
+* t2 r.lock（**读锁**），进入 tryAcquireShared 流程：
 
   * 返回 -1 表示失败
   * 如果返回 0 表示成功
-  * 返回正数表示还有多少后继节点支持共享模式，读写锁返回1
+  * 返回正数表示还有多少后继节点支持共享模式，读写锁返回 1
 
   ```java
   public void lock() {
@@ -9451,28 +9549,113 @@ public static void main(String[] args) {
   protected final int tryAcquireShared(int unused) {
       Thread current = Thread.currentThread();
       int c = getState();
-      // 低 16 位, 代表写锁的 state
-      // 如果是其它线程持有写锁, 并且写锁的持有者不是当前线程，获取读锁失败，【写锁允许降级】
+      // exclusiveCount(c) 代表低 16 位, 写锁的 state，成立说明有线程持有写锁
+      // 写锁的持有者不是当前线程，则获取读锁失败，【写锁允许降级】
       if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current)
           return -1;
       
-      // 高 16 位，代表读锁的 state
+      // 高 16 位，代表读锁的 state，共享锁分配出去的总次数
       int r = sharedCount(c);
-      if (!readerShouldBlock() &&	// 读锁不该阻塞
-          r < MAX_COUNT &&		// 小于读锁计数	
-          compareAndSetState(c, c + SHARED_UNIT)) {// 尝试增加计数成功
-          // ....
+      // 读锁是否应该阻塞
+      if (!readerShouldBlock() &&	r < MAX_COUNT &&
+          compareAndSetState(c, c + SHARED_UNIT)) {	// 尝试增加读锁计数
+          // 加锁成功
+          // 加锁之前读锁为 0，说明当前线程是第一个读锁线程
+          if (r == 0) {
+              firstReader = current;
+              firstReaderHoldCount = 1;
+          // 第一个读锁线程是自己就发生了读锁重入
+          } else if (firstReader == current) {
+              firstReaderHoldCount++;
+          } else {
+              // cachedHoldCounter 设置为当前线程的 holdCounter 对象，即最后一个获取读锁的线程
+              HoldCounter rh = cachedHoldCounter;
+              // 说明还没设置 rh
+              if (rh == null || rh.tid != getThreadId(current))
+                  // 获取当前线程的锁重入的对象，赋值给 cachedHoldCounter
+                  cachedHoldCounter = rh = readHolds.get();
+              // 还没重入
+              else if (rh.count == 0)
+                  readHolds.set(rh);
+              // 重入 + 1
+              rh.count++;
+          }
           // 读锁加锁成功
           return 1;
       }
-      // 与 tryAcquireShared 功能类似, 但会不断尝试 for (;;) 获取读锁, 执行过程中无阻塞
+      // 逻辑到这 应该阻塞，或者 cas 加锁失败
+      // 会不断尝试 for (;;) 获取读锁, 执行过程中无阻塞
       return fullTryAcquireShared(current);
   }
-  // 非公平锁 readerShouldBlock 看 AQS 队列中第一个节点是否是写锁，是则阻塞，反之不阻塞
+  // 非公平锁 readerShouldBlock 偏向写锁一些，看 AQS 阻塞队列中第一个节点是否是写锁，是则阻塞，反之不阻塞
+  // 防止一直有读锁线程，导致写锁线程饥饿
   // true 则该阻塞, false 则不阻塞
   final boolean readerShouldBlock() {
       return apparentlyFirstQueuedIsExclusive();
   }
+  final boolean readerShouldBlock() {
+      return hasQueuedPredecessors();
+  }
+  ```
+
+  ```java
+  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) {
+                  // assert firstReaderHoldCount > 0;
+              } else {
+                  if (rh == null) {
+                      // 最后一个读锁的 HoldCounter
+                      rh = cachedHoldCounter;
+                      // 说明当前线程也不是最后一个读锁
+                      if (rh == null || rh.tid != getThreadId(current)) {
+                          // 获取当前线程的 HoldCounter
+                          rh = readHolds.get();
+                          // 条件成立说明 HoldCounter 对象是上一步代码新建的
+                          // 当前线程不是锁重入，在 readerShouldBlock() 返回 true 时需要去排队
+                          if (rh.count == 0)
+                              // 防止内存泄漏
+                              readHolds.remove();
+                      }
+                  }
+                  if (rh.count == 0)
+                      return -1;
+              }
+          }
+          // 越界判断
+          if (sharedCount(c) == MAX_COUNT)
+              throw new Error("Maximum lock count exceeded");
+          // 读锁加锁，条件内的逻辑与 tryAcquireShared 相同
+          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;
+          }
+      }
+  }
   ```
 
 * 获取读锁失败，进入 sync.doAcquireShared(1) 流程开始阻塞，首先也是调用 addWaiter 添加节点，不同之处在于节点被设置为 Node.SHARED 模式而非 Node.EXCLUSIVE 模式，注意此时 t2 仍处于活跃状态
@@ -9603,7 +9786,7 @@ public static void main(String[] args) {
               else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                   continue;                
           }
-          // 条件不成立说明被唤醒的节点非常积极，直接将自己设置为了新的head，
+          // 条件不成立说明被唤醒的节点非常积极，直接将自己设置为了新的 head，
           // 此时唤醒它的节点（前驱）执行 h == head 不成立，所以不会跳出循环，会继续唤醒新的 head 节点的后继节点
           if (h == head)                   
               break;
@@ -9632,7 +9815,7 @@ public static void main(String[] args) {
   
   ```java
   protected final boolean tryReleaseShared(int unused) {
-      //  
+  
       for (;;) {
           int c = getState();
           int nextc = c - SHARED_UNIT;
