CountDownLatch

CountDownLatch

CountDownLatch 源码

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

public class MyCountDownLatch {
    /**
     * 通过AQS实现闭锁的同步控制，AQS的state为闭锁的count
     */
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
        Sync(int count) {
            //初始化state
            setState(count);
        }
        int getCount() {
            //获取state
            return getState();
        }
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }

        /**
         * 共享锁，通过CAS对state减一
         */
        protected boolean tryReleaseShared(int releases) {
            //自旋锁
            for (; ; ) {
                //获取state
                int c = getState();
                if (c == 0)
                    //如果state为零直接返回false，不做任何处理。不进行对state减一
                    return false;
                //对state减一
                int nextc = c - 1;
                //CAS更新state为nextc
                if (compareAndSetState(c, nextc))
                    //更新后如果state为零返回ture。
                    return nextc == 0;
            }
        }
    }
    private final MyCountDownLatch.Sync sync;
    public MyCountDownLatch(int count) {
        //count必须大于等于零
        if (count < 0) throw new IllegalArgumentException("count < 0");
        //初始化state
        this.sync = new MyCountDownLatch.Sync(count);
    }

    /**
     * 当前线程阻塞，直到state为零或者被线程被中断。
     * 如果state为零，不会阻塞。
     */
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    /**
     * 设置wait时间，到期无论state是否为零，直接退出阻塞。
     */
    public boolean await(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    /**
     * 如果state不为零对state减一，否则什么也不做。
     */
    public void countDown() {
        sync.releaseShared(1);
    }

    public long getCount() {
        //当前count的值
        return sync.getCount();
    }
    public String toString() {
        //闭锁的类信息和当前count的值
        return super.toString() + "[Count = " + sync.getCount() + "]";
    }
}

 

CountDownLatch 使用

/**
     * 同步一个或者多个任务，强制他们等待由其他任务执行的一组操作完成。
     */
    public static void myCountDownLatch() {
        final CountDownLatch countDownLatch = new CountDownLatch(3);
        ExecutorService executorService = Executors.newFixedThreadPool(100);

        ExecutorService executorServiceWait = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 6; i++) {
            final int j = i;
            executorService.execute(() -> {
                //do something
                try {
                    TimeUnit.MILLISECONDS.sleep(300 * j);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                logger.info("序列号：" + j + countDownLatch.toString());
                //执行完任务count减一，count为零时不可再进行减一，一直保持为零,为零的临界点只能触发一次。
                countDownLatch.countDown();
            });
        }
        for (int i = 0; i < 2; i++) {
            executorServiceWait.execute(() -> {

                logger.info("闭锁 start" + countDownLatch.toString());
                try {
                    //当count为零时，释放阻塞。
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    logger.error("myCountDownLatch", e);
                }
                logger.info("闭锁 end" + countDownLatch.toString());

            });
        }

        executorService.shutdown();
        executorServiceWait.shutdown();
    }