队列同步器的实现

队列同步器主要包括：

　　1. 同步队列

　　2. 首节点（head）

　　3. 尾节点（tail）

　　4 独占式获取与释放同步状态

　　5. 共享式获取与释放同步状态

　　6. 超时获取与释放同步状态

 1.同步队列：

　　1.1 一个FIFO双向队列

　　1.2 当前线程获取同步状态失败时，会向队列中添加节点（Node）

　　　　节点的组成：

• • • 线程的引用（获取同步状态失败的线程）　-- Thread thread
    • 等待状态 -- int waitStatus 
      • • CANCELLED 值为1.
        • SIGNAL 值为-1
        • CONDITION 值为-2
        • PROPAGATE 值为-3
        • INITIAL 值为0
    • 前驱结点 -- Node prev 前驱节点 当节点加入同步队列时被设置
    • 后继节点 -- Node next 
    •  -- Node nextWaiter

2. 首节点和尾节点的操作逻辑　　　

2.1 当一个线程成功地获取了同步状态（或者锁）,其他的线程将无法获取到同步状态，转而被构造称为节点并加入到同步队列的尾部。同时有多个尾节点插入同步队列是线程不安全的。同步器提供了一个基于CAS的设置尾节点的方法来保证线程安全：compareAndSetTail(Node except, Node update)---它需要传递当前线程“认为”的尾节点和当前节点，只有设置成功后，当前节点才正式与之前的尾节点建立关联。

 

2.2 首节点是获取同步状态成功的节点，首节点的线程在释放同步状态（或者解锁）时，将会唤醒后继节点，而后继节点会在获取同步状态成功时将自己设置为首节点（head）

 

3 独占式同步状态获取与释放 

 通过调用同步器的acquire(int arg)方法可以获取同步状态，该方法对中断不敏感，也就是由于线程获取同步状态失败后进入同步队列中，后续对该线程进行中断操作时，线程不会从同步队列中移出 

//同步器的acquire方法 
public final void acquire(int arg) {
     if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
         selfInterrupt();
}   

 主要逻辑是：首先调用自定义同步器实现的tryAcquire(int arg)方法，该方法保证线程安全的获取同步状态，如果同步状态获取失败，则构造同步节点（独占式Node.EXCLUSIVE，同一时刻只能有一个线程成功获取同步状态）并通过addWaiter(Node node)方法将该节点加入到同步队列的尾部，最后调用acquireQueued(Node node,int arg)方法，使得该节点以“死循环”的方式获取同步状态。如果获取不到则阻塞节点中的线程，而被阻塞线程的唤醒主要依靠前驱节点的出队或阻塞线程被中断来实现 

//同步器的addWaiter和enq方法
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // 快速尝试在尾部添加
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}
//如果不存在尾节点，先初始化尾节点（和头节点），然后再设置尾节点
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

在enq(final Node node)方法中，同步器通过“死循环”来保证节点的正确添加，在“死循环”中只有通过CAS将节点设置成为尾节点之后，当前线程才能从该方法返回，否则，当前线程不断地尝试设置。可以看出，enq(final Node node)方法将并发添加节点的请求通过CAS变得“串行化”了。

节点进入同步队列之后，就进入了一个自旋的过程，每个节点（或者说每个线程）都在自省地观察，当条件满足，获取到了同步状态，就可以从这个自旋过程中退出，否则依旧留在这个自旋过程中（并会阻塞节点的线程），代码如下：

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
           }
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
     }
}

 在acquireQueued(final Node node,int arg)方法中，当前线程在“死循环”中尝试获取同步状态，只有前驱节点是头节点才能够尝试获取同步状态，如图：

独占式同步状态获取流程，也就是acquire(int arg)方法调用流程，如图5-5所示。

当前线程获取同步状态并执行了相应逻辑之后，就会调用同步器的release(int arg)方法释放同步状态
 

//同步器的release方法
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

 该方法执行时，会唤醒头节点的后继节点线程，unparkSuccessor(Node node)方法使用LockSupport（在后面的章节会专门介绍）来唤醒处于等待状态的线程
 

 总结：在获取同步状态时，同步器维护一个同步队列，获取状态失败的线程都会被加入到队列中并在队列中进行自旋；移出队列（或停止自旋）的条件是前驱节点为头节点且成功获取了同步状态。在释放同步状态时，同步器调用tryRelease(int arg)方法释放同步状态，然后唤醒头节点的后继节点 

4.共享式同步状态获取与释放

同一时刻可以有多个线程同时获取到同步状态。 

 

通过调用同步器的acquireShared(int arg)方法可以共享式地获取同步状态 

//同步器的acquireShared和doAcquireShared方法
public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)//tryAcquireShared(int arg)方法返回值为int类型，当返回值大于等于0时，表示能够获取到同
步状态 
        doAcquireShared(arg);
}
private void doAcquireShared(int arg) {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null;
                    if (interrupted)
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
          if (failed)
              cancelAcquire(node);
    }
}

与独占式一样，共享式获取也需要释放同步状态，通过调用releaseShared(int arg)方法可以释放同步状态

//释放同步状态
public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

tryReleaseShared(int arg)方法必须确保同步状态（或者资源数）线程安全释放，一般是通过循环和CAS来保证的，因为释放同步状态的操作会同时来自多个线程

5.独占式超时获取同步状态

通过调用同步器的doAcquireNanos(int arg,long nanosTimeout)方法可以响应中断和超时获取同步状态，即在指定的时间段内获取同步状态，如果获取到同步状态则返回true，否则，返回false。

private boolean doAcquireNanos(int arg, long nanosTimeout) throws InterruptedException {
    long lastTime = System.nanoTime();final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return true;
            }
            if (nanosTimeout <= 0)
                return false;
            if (shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold)
                LockSupport.parkNanos(this, nanosTimeout);
            long now = System.nanoTime();
            //计算时间，当前时间now减去睡眠之前的时间lastTime得到已经睡眠
            //的时间delta，然后被原有超时时间nanosTimeout减去，得到了
            //还应该睡眠的时间
            nanosTimeout -= now - lastTime;
            lastTime = now;
            if (Thread.interrupted())
                throw new InterruptedException();
        }
     } finally {
          if (failed)
              cancelAcquire(node);
     }
}    

如果当前线程获取同步状态失败，则判断是否超时（nanosTimeout小于等于0表示已经超时），如果没有超时，重新计算超时间隔nanosTimeout，然后使当前线程等待nanosTimeout纳秒（当已到设置的超时时间，该线程会从LockSupport.parkNanos(Objectblocker,long nanos)方法返回）。
如果nanosTimeout小于等于spinForTimeoutThreshold（1000纳秒）时，将不会使该线程进行超时等待，而是进入快速的自旋过程。 

6.自定义同步组件——TwinsLock （该工具在同一时刻，只允许至多两个线程同时访问，超过两个线程的访问将被阻塞 ）

　　步骤：

1.  重写tryAcquireShared(int args)方法和tryReleaseShared(int args)方法

2. 定义资源数。TwinsLock在同一时刻允许至多两个线程的同时访问，表明同步资源数为2，这样可以设置初始状态status为2，当一个线程进行获取，status减1，该线程释放，则status加1，状态的合法范围为0、1和2，其中0表示当前已经有两个线程获取了同步资源。

public class TwinsLock implements Lock {
    private final Sync sync = new Sync(2);//定义资源数为2
    private static final class Sync extends AbstractQueuedSynchronizer {
        Sync(int count) {
            if (count <= 0) {
                throw new IllegalArgumentException("count must large than zero.");
            }
            setState(count);//初始化同步状态--同步状态的初始值为同步资源数
        }
        public int tryAcquireShared(int reduceCount) {
            for (;;) {
                int current = getState();
　　　　　　　　　 int newCount = current - reduceCount;
                if (newCount < 0 || compareAndSetState(current, newCount)) {
                    return newCount;
                }
            }
        }
        public boolean tryReleaseShared(int returnCount) {
            for (;;) {
                int current = getState();
                int newCount = current + returnCount;
                if (compareAndSetState(current, newCount)) {
                    return true;
                }
            }
        }
    }
    public void lock() {
        sync.acquireShared(1);
    }
    public void unlock() {
        sync.releaseShared(1);
    }
    // 其他接口方法略
}   

同步器会先计算出获取后的同步状态，然后通过CAS确保状态的正确设置，当tryAcquireShared(int reduceCount)方法返回值大于等于0时，当前线程才获取同步状态（锁）。

测试TwinsLock：

在测试用例中，定义了工作者线程Worker，该线程在执行过程中获取锁，当获取锁之后使当前线程睡眠1秒（并不释放锁），随后打印当前线程名称，最后再次睡眠1秒并释放锁 

//测试TwinsLock
public class TwinsLockTest {
　　@Test
　　public void test() {
　　　　final Lock lock = new TwinsLock();
　　　　class Worker extends Thread {
　　　　public void run() {
　　　　　　while (true) {
　　　　　　　　lock.lock();
　　　　　　　　try {
　　　　　　　　　　SleepUtils.second(1);
　　　　　　　　　　System.out.println(Thread.currentThread().getName());
　　　　　　　　　　SleepUtils.second(1);
　　　　　　　　} finally {
　　　　　　　　　　lock.unlock();
　　　　　　　　}
　　　　　　}
　　　　　}
　　　　}
　　　　// 启动10个线程
　　　　for (int i = 0; i < 10; i++) {
　　　　　　Worker w = new Worker();
　　　　　　w.setDaemon(true);
　　　　　　w.start();
　　　　}
　　　　// 每隔1秒换行
　　　　for (int i = 0; i < 10; i++) {
　　　　　　SleepUtils.second(1);
　　　　　　System.out.println();
　　　　}
　　}
}