【线程】并发流程控制的同步工具-CountDownLatch

//减少锁存器的计数，如果计数达到零，则释放所有等待线程。 
//计数器 
public void countDown() { 
    sync.releaseShared(1); 
} 
//导致当前线程等待，直到锁存器递减至零为止，除非该线程被中断。 
//火锅店调用await的线程，count为0才能继续执行 
public void await() throws InterruptedException { 
    sync.acquireSharedInterruptibly(1); 
}

//count 数量，理解为小伙伴的个数 
public CountDownLatch(int count) { 
    if (count < 0) throw new IllegalArgumentException("count < 0"); 
        this.sync = new Sync(count); 
} 
//获取剩余的数量 
public long getCount() { 
    return sync.getCount(); 
}

public boolean await(long timeout, TimeUnit unit) throws InterruptedException { 
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout)); 
} 
//当状态不为0挂起，表示当前线程被占有，需要线程排队 
protected int tryAcquireShared(int acquires) { 
    return (getState() == 0) ? 1 : -1; 
} 
//在共享模式下获取 
doAcquireSharedInterruptibly(int arg)

public void countDown() { 
    sync.releaseShared(1); 
} 
protected boolean tryReleaseShared(int releases) { 
// Decrement count; signal when transition to zero 
//自旋防止失败 
    for (;;) { 
        //获取状态
        int c = getState(); 
        //状态为为0返回false，表示没有被线程占有 
        if (c == 0) return false; 
        //调用cas来进行替换，也保证了线程安全，当为0的时候唤醒 
        int nextc = c-1; 
        if (compareAndSetState(c, nextc)) 
            return nextc == 0; 
    } 
} 
//当任务数量为0，aqs的释放共享锁 
void doReleaseShared()

private void doReleaseShared() {
    /*
        * Ensure that a release propagates, even if there are other
        * in-progress acquires/releases.  This proceeds in the usual
        * way of trying to unparkSuccessor of head if it needs
        * signal. But if it does not, status is set to PROPAGATE to
        * ensure that upon release, propagation continues.
        * Additionally, we must loop in case a new node is added
        * while we are doing this. Also, unlike other uses of
        * unparkSuccessor, we need to know if CAS to reset status
        * fails, if so rechecking.
        */
    // 无限循环
    for (;;) {
        // 保存头节点
        Node h = head;
        // 头节点不为空并且头节点不为尾结点
        if (h != null && h != tail) { 
            // 获取头节点的等待状态
            int ws = h.waitStatus; 
            if (ws == Node.SIGNAL) { 
                // 状态为SIGNAL,CAS更新状态
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) 
                    continue;            // loop to recheck cases
                // 释放后继结点
                unparkSuccessor(h);
            }
            // 状态为0并且更新不成功，继续
            else if (ws == 0 &&
                        !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) // 
                continue;                // loop on failed CAS
        }
        if (h == head) // 若头节点改变，继续循环  
            break;
    }
}

public class CountDownLatchTest {
    private static Lock lock = new ReentrantLock();
    private static CountDownLatch countDownLatch = new CountDownLatch(4);
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        IntStream.range(0,16).forEach(i ->{
            executorService.submit(()->{
                lock.lock();
                System.out.println(Thread.currentThread().getName()+ "来火锅店吃火锅！");
                try {
                    Thread.sleep(1000);
                    countDownLatch.countDown();
                    System.out.println(Thread.currentThread().getName() + "我到火锅店了，准备开吃！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            });
        });
        try {
            countDownLatch.await(5,TimeUnit.SECONDS);
            System.out.println("人到齐了，开饭");
            executorService.shutdown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class CountDownLatchTest2 {
    private static Lock lock = new ReentrantLock();
    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        IntStream.range(0,4).forEach(i ->{
            executorService.submit(()->{
                System.out.println(Thread.currentThread().getName()+ "准备开始抢位子！");
                try {
                    //Thread.sleep(1000);
                    countDownLatch.await();
                    System.out.println(Thread.currentThread().getName() + "抢到了位置");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        });
        try {
            Thread.sleep(5000);
            System.out.println("五秒后开始抢位置");
            countDownLatch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
    }
}