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

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

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

公平模式ReentrantLock实现原理前面的文章研究了AbstractQueuedSynchronizer的独占锁和共享锁，有了前两篇文章的基础，就可以乘胜追击，看一下基于AbstractQueuedSynchronizer的并发类是如何实现的。
ReentrantLock显然是一种独占锁，首先是公平模式的ReentrantLock，Sync是ReentractLock中的基础类，继承自AbstractQueuedSynchronizer，看一下代码实现：

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;

/**
   * Performs {@link Lock#lock}. The main reason for subclassing
   * is to allow fast path for nonfair version.
   */
abstract void lock();

/**
   * Performs non-fair tryLock.  tryAcquire is
   * implemented in subclasses, but both need nonfair
   * try for trylock method.
   */
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;
}

protected final boolean tryRelease(int releases) {
      int c = getState() - releases;
      if (Thread.currentThread() != getExclusiveOwnerThread())
         throw new IllegalMonitorStateException();
      boolean free = false;
      if (c == 0) {
         free = true;
         setExclusiveOwnerThread(null);
      }
      setState(c);
      return free;
}

protected final boolean isHeldExclusively() {
      // While we must in general read state before owner,
      // we don't need to do so to check if current thread is owner
      return getExclusiveOwnerThread() == Thread.currentThread();
}

final ConditionObject newCondition() {
      return new ConditionObject();
}

// Methods relayed from outer class

final Thread getOwner() {
      return getState() == 0 ? null : getExclusiveOwnerThread();
}

final int getHoldCount() {
      return isHeldExclusively() ? getState() : 0;
}

final boolean isLocked() {
      return getState() != 0;
}

/**
   * Reconstitutes this lock instance from a stream.
   * @param s the stream
   */
private void readObject(java.io.ObjectInputStream s)
      throws java.io.IOException, ClassNotFoundException {
      s.defaultReadObject();
      setState(0); // reset to unlocked state
}
}

Sync属于一个公共类，它是抽象的说明Sync会被继承，简单整理一下Sync主要做了哪些事（因为Sync不是ReentrantLock公平锁的关键）：

定义了一个lock方法让子类去实现，我们平时之所以能调用ReentrantLock的lock()方法，就是因为Sync定义了它
实现了非公平锁tryAcquira的方法
实现了tryRelease方法，比较简单，状态-1，独占锁的线程置空
实现了isHeldExclusively方法
定义了newCondition方法，让开发者可以利用Condition实现通知/等待

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