电子技术论坛_中国专业的电子工程师学习交流社区-中电网技术论坛

标题: 基于 AbstractQueuedSynchronizer 的并发类实现（2） [打印本页]

作者: look_w 时间: 2019-1-17 19:49 标题: 基于 AbstractQueuedSynchronizer 的并发类实现（2）

接着，看一下公平锁的实现，FairSync类，它继承自Sync：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;

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

/**
   * Fair version of tryAcquire.  Don't grant access unless
   * recursive call or no waiters or is first.
   */
protected final boolean tryAcquire(int acquires) {
      final Thread current = Thread.currentThread();
      int c = getState();
      if (c == 0) {
         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;
}
}

整理一下要点：
1. 每次acquire的时候，state+1，如果当前线程lock()之后又lock()了，state不断+1，相应的unlock()的时候state-1，直到将state减到0为之，说明当前线程释放完所有的状态，其它线程可以竞争
2. state=0的时候，通过hasQueuedPredecessors方法做一次判断，hasQueuedPredecessors的实现为”h != t && ((s = h.next) == null || s.thread != Thread.currentThread());”，其中h是head、t是tail，由于代码中对结果取反，因此取反之后的判断为”h == t || ((s = h.next) != null && s.thread == Thread.currentThread());”，总结起来有两种情况可以通过!hasQueuedPredecessors()这个判断：

h==t，h==t的情况为要么当前FIFO队列中没有任何数据，要么只构建出了一个head还没往后面连过任何一个Node，因此head就是tail
(s = h.next) != null && s.thread == Thread.currentThread()，当前线程为正在等待的第一个Node中的线程

3. 如果没有线程比当前线程等待更久去执行acquire操作，那么通过CAS操作将state从0变为1的线程tryAcquire成功
4. 没有tryAcquire成功的线程，按照tryAcquire的先后顺序，构建为一个FIFO队列，即第一个tryAcquire失败的排在head的后一位，第二个tryAcquire失败的排在head的后二位
5. 当tryAcquire成功的线程release完毕，第一个tryAcquire失败的线程第一个尝试tryAcquire，这就是先到先得，典型的公平锁

欢迎光临电子技术论坛_中国专业的电子工程师学习交流社区-中电网技术论坛 (http://bbs.eccn.com/)