AbstractQueuedSynchronizer的使用和juc里的相关类的解析

对AQS进行解析后，先来实现两个简单的基于AQS的类，然后再解析juc里基于AQS构造的类。

1、基于AQS的类的示例

首先先看这个类，这个类是《Java并发编程实战》的一个示例，AQS源码的注释里也给了类似的实现。这个类是以共享模式实现的，在调用signal之前，调用await方法的线程都将被阻塞，main方法的示例演示了这种情况。

 1 public class Latch {
 2     private Sync sync = new Sync();
 3
 4     private class Sync extends AbstractQueuedSynchronizer{
 5         @Override
 6         protected int tryAcquireShared(int arg) {//重写tryAcquireShared方法
 7             return getState() == 1 ? 1 : -1;
 8         }
 9
10         @Override
11         protected boolean tryReleaseShared(int arg) {//重写tryReleaseShared方法
12             setState(1);
13             return true;
14         }
15     }
16
17     public void signal(){//调用这个方法会调用releaseShared方法，会调用tryReleaseShared方法，将state设置为0 没调用这个方法之前调用tryAcquireShared的返回值都是0，线程会阻塞
18         sync.releaseShared(0);
19     }
20
21     public void await() throws InterruptedException {//调用这个方法会调用acquireSharedInterruptibly方法，会调用tryAcquireShared方法，如果返回值大于0，则集训运行；否则阻塞
22         sync.acquireSharedInterruptibly(0);
23     }
24
25     public static void main(String [] args) throws InterruptedException {
26         Latch latch = new Latch();
27         Runnable runnable = new Runnable() {
28             @Override
29             public void run() {
30                 try {
31                     latch.await();
32                 } catch (InterruptedException e) {
33                     e.printStackTrace();
34                 }
35                 System.out.println("haha");
36             }
37         };
38
39         new Thread(runnable).start();
40         new Thread(runnable).start();
41
42         Thread.sleep(5 * 1000);
43
44         System.out.println("xixi");
45         latch.signal();
46     }
47 }

这个类是AQS注释里给出的一个实现的一部分。这个类是以独占模式实现的。同时只能有一个线程

 1 public class Mock {
 2     private Sync sync = new Sync();
 3
 4     private class Sync extends AbstractQueuedSynchronizer{
 5         @Override
 6         protected boolean isHeldExclusively() {
 7             return getState() == 1;
 8         }
 9
10         @Override
11         protected boolean tryAcquire(int acquires) {//重写tryAcquire方法，用cas尝试将state从0置为1
12             assert acquires == 1;
13             if (compareAndSetState(0, 1)){
14                 setExclusiveOwnerThread(Thread.currentThread());//如果将state从0置为1成功，则将当前线程设置为独占模式持有资源的线程
15                 return true;
16             }
17             return false;
18         }
19
20         @Override
21         protected boolean tryRelease(int releases) {
22             assert releases == 1;
23             if (getState() == 0){//如果state为0，则说明资源没有被占用，不需要释放 抛出一个异常
24                 throw new IllegalMonitorStateException();
25             }
26             setExclusiveOwnerThread(null);//将资源拥有者线程置为null
27             setState(0);//将state置为0，资源释放
28             return true;
29         }
30     }
31
32     @Test
33     public void lock(){
34         sync.acquire(1);
35     }
36
37     public boolean tryAcquire(){
38         return sync.tryAcquire(1);
39     }
40
41     public void unlock(){
42         sync.release(1);
43     }
44
45     public static void main(String [] args) throws InterruptedException {
46         Mock mock = new Mock();
47         Runnable runnable = new Runnable() {
48             @Override
49             public void run() {
50                 mock.lock();
51                 System.out.println("haha");
52                 try {
53                     Thread.sleep(5 * 1000);
54                 } catch (InterruptedException e) {
55                     e.printStackTrace();
56                 }
57                 mock.unlock();
58             }
59         };
60
61         new Thread(runnable).start();
62         new Thread(runnable).start();
63
64         mock.lock();
65         System.out.println("xixi");
66         Thread.sleep(5 * 1000);
67         mock.unlock();
68     }
69 }

2、juc里基于AQS构造的类

Semaphore类：

内部抽象类Sync：

 1     abstract static class Sync extends AbstractQueuedSynchronizer {
 2         private static final long serialVersionUID = 1192457210091910933L;
 3
 4         Sync(int permits) {
 5             setState(permits);
 6         }
 7
 8         final int getPermits() {
 9             return getState();
10         }
11
12         final int nonfairTryAcquireShared(int acquires) {//不公平尝试获取共享锁
13             for (;;) {
14                 int available = getState();
15                 int remaining = available - acquires;
16                 if (remaining < 0 ||
17                     compareAndSetState(available, remaining))//如果剩下的资源不够分配，直接返回，会进入阻塞状态；如果剩下的资源足够分配，自旋直到分配成功，返回分配后剩下的资源
18                     return remaining;
19             }
20         }
21
22         protected final boolean tryReleaseShared(int releases) {//尝试释放锁
23             for (;;) {//自旋
24                 int current = getState();
25                 int next = current + releases;
26                 if (next < current)//next溢出为负数 抛出异常
27                     throw new Error("Maximum permit count exceeded");
28                 if (compareAndSetState(current, next))//cas修改state
29                     return true;
30             }
31         }
32
33         final void reducePermits(int reductions) {//减少许可
34             for (;;) {
35                 int current = getState();
36                 int next = current - reductions;
37                 if (next > current) // underflow
38                     throw new Error("Permit count underflow");
39                 if (compareAndSetState(current, next))
40                     return;
41             }
42         }
43
44         final int drainPermits() {//将许可清空
45             for (;;) {
46                 int current = getState();
47                 if (current == 0 || compareAndSetState(current, 0))
48                     return current;
49             }
50         }
51     }

内部类NonfairSync：

这个类继承自抽象类Sync，实现了tryAcquireShared方法，由类名可知这个类是非公平获取资源的（非公平就是说一个线程尝试获取资源时，就算有其它线程在排队获取资源，但是由于这些资源处于等待状态，会让新的线程先尝试获取资源，如果直接能获取就让新线程直接运行，不再进入等待队列排队；如果不能直接获取，就再进入阻塞队列。非公平可能减少线程阻塞唤醒的次数，性能要比公平好一些）。

在AQS里的acquireShared方法会先调用tryAcquireShared方法再根据结果决定是执行还是等待，这里tryAcquireShared的实现就可以让Semaphore有非公平的功能。

 1     static final class NonfairSync extends Sync {
 2         private static final long serialVersionUID = -2694183684443567898L;
 3
 4         NonfairSync(int permits) {
 5             super(permits);
 6         }
 7
 8         protected int tryAcquireShared(int acquires) {
 9             return nonfairTryAcquireShared(acquires);
10         }
11     }

内部类FairSync：

上面说了非公平的版本，公平的版本和非公平的版本区别就在tryAcquireShared方法里面。在FairSync里，如果队列里有其它线程等待，就直接返回-1，新线程会直接放入队列中；如果没有其它线程等待才尝试获取资源。

 1     static final class FairSync extends Sync {
 2         private static final long serialVersionUID = 2014338818796000944L;
 3
 4         FairSync(int permits) {
 5             super(permits);
 6         }
 7
 8         protected int tryAcquireShared(int acquires) {
 9             for (;;) {
10                 if (hasQueuedPredecessors())
11                     return -1;
12                 int available = getState();
13                 int remaining = available - acquires;
14                 if (remaining < 0 ||
15                     compareAndSetState(available, remaining))
16                     return remaining;
17             }
18         }
19     }

Semaphore的构造函数：

Semaphore的构造函数有两个，都需要传许可（资源）数，另一个可以传是否公平，来决定资源分配的方式。

1     public Semaphore(int permits) {
2         sync = new NonfairSync(permits);
3     }
4
5     public Semaphore(int permits, boolean fair) {
6         sync = fair ? new FairSync(permits) : new NonfairSync(permits);
7     }

Semaphore的其它方法基本上都是调用Sync(AQS)的方法实现的，可以看AQS的解析或Semaphore抽象内部类Sync的解析。

CountDownLatch类：

CountDownLatch类中文翻译为闭锁，它的工作机制是设定一个初值，在初值减为0之前调用await方法会使当前线程进入等待状态，调用countDown减到0时会将其它等待的线程唤醒。和Semaphore类似，它的功能也主要由继承AQS构建Sync实现。

内部类Sync：

 1     private static final class Sync extends AbstractQueuedSynchronizer {
 2         private static final long serialVersionUID = 4982264981922014374L;
 3
 4         Sync(int count) {
 5             setState(count);
 6         }
 7
 8         int getCount() {
 9             return getState();
10         }
11
12         protected int tryAcquireShared(int acquires) {//如果state减到1，返回都为正；如果没有减到1，返回都为负
13             return (getState() == 0) ? 1 : -1;
14         }
15
16         protected boolean tryReleaseShared(int releases) {
17             // Decrement count; signal when transition to zero
18             for (;;) {
19                 int c = getState();
20                 if (c == 0)
21                     return false;
22                 int nextc = c-1;//nextc是c-1
23                 if (compareAndSetState(c, nextc))//每次调用都将state减去一
24                     return nextc == 0;
25             }
26         }
27     }

await方法：

sync调用acquireSharedInterruptibly方法会调用上面实现的tryAcquireShared，如果state没减到0就返回负，线程等待进入队列。

1     public void await() throws InterruptedException {
2         sync.acquireSharedInterruptibly(1);
3     }

countDown方法：

sync调用releaseShared方法会调用上面实现的tryReleaseShared，然后会调用AQS的doReleaseShared唤醒队首的线程，队首的线程获取资源时会唤醒后面线程（因为此时调用tryAcquireShared返回值一直为正），后面线程唤醒再后面线程，直至全部唤醒。

1     public void countDown() {
2         sync.releaseShared(1);
3     }

可重入锁的实现要复杂一点，另开一篇。