j.u.c同步工具

同步工具：

java.util.concurrent.CountDownLatch

CountDownLatch， 当count减为0， 唤醒锁同步队列中的线程。

借助共享锁实现，

// count就是AQS中status的值， 共享锁状态
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

释放共享锁，每次调用AQS的status减1

    public void countDown() {

// 当status减为0， 则唤醒锁同步队列中的线程。
        sync.releaseShared(1);
    }

获取共享锁失败， 把线程加入到锁同步队列；

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

 private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        Sync(int count) {
            setState(count);
        }

        int getCount() {
            return getState();
        }

        // 当status减为0， 成功获取共享锁。
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }


        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0; // 当status减为0， 释放锁成功， 唤醒锁同步队列中的线程

            }
        }
    }

AQS释放共享锁

public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) { // 共享锁释放成功
            doReleaseShared(); // 唤醒锁同步队列中的线程
            return true;
        }
        return false;
    }

java.util.concurrent.Semaphore

Semaphores are often used to restrict the number of threads than can access some (physical or logical) resource.

用来限制同一时刻访问相同资源的线程数量。

// the initial number of permits available.
// 同一时刻最多允许通过的线程数量

  public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

同步工具 java.util.concurrent.CyclicBarrier

CyclicBarrier，回环栅栏

提前到达栅栏的线程等待没有到达的线程； 只有当指定数量的线程都到达栅栏，栅栏放行所有线程；栅栏在放行所有线程之前， 由最后一个到达栅栏的线程执行barrierAction操作。

用于并行计算， 将大任务拆分成几个小任务， 每个线程执行一个小任务， 提前完成任务的线程进入Condition等待队列，最后一个完成小任务的线程负责执行barrierAction， 在barrierAction中负责将多个小任务的执行结果合并。