实现CountDownLatch相似功能

2017-06-26

1. CountDownLatch

1.1 简介

CountDownLatch是一个同步工具类，允许一个或多个线程等待其他线程操作完成后才执行，比如生活中炒菜的例子，要炒菜之前，得准备好油盐酱醋，切好菜，准备好工具，等待这些工作做完了，才可以真的炒菜，用线程方式表示就是

线程A ：炒菜
线程B ：酱料准备
线程C ：切菜
线程D ：工具
当线程B，C，D操作完成，线程A才会执行，CountDownLatch就是实现这种需求的工具类。

1.2 使用代码

public class CountDownLatchDemo implements Runnable{
    static CountDownLatch end = new CountDownLatch(10);
    static CountDownLatchDemo demo = new CountDownLatchDemo();
    @Override
    public void run() {
        try {
            //模拟检查
            Thread.sleep(new Random().nextInt(10)*1000);
            end.countDown();
            System.out.println("check over ,count = "+end.getCount());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String args[]) throws InterruptedException {
        ExecutorService exec = Executors.newFixedThreadPool(10);
        for(int i = 0;i<10;i++){
            exec.submit(demo);
        }
        //等待其他线程完成
        end.await();
        System.out.println("count数量为 "+end.getCount()+",其他准备工作已完成!");
        exec.shutdown();
    }
}

2. 实现简单CountDownLatch

2.1 思路

使用Condition的await方法实现线程等待，使用Condition的signal方法实现唤醒

countDown()
1. count计数减一
2. 当count为0时，使用Condition实例的signal方法来唤醒最终线程
await()

使用Condition实例的await方法
注意点
1. Condition实例方法得配合ReentrantLock来使用
2. 使用Condition的await和signal之前，都得使用ReentrantLock获得锁，就像Object.wait()使用前得获取对象锁一样，也就是获取监视器
  | 方法 | 监视器 |
  | —- | — |
  | Object.wait() Object.notify() | Monitor |
  | await() signal() | ReentrantLock.lock() |

2.2 代码

public class ConditionCountDownDemo implements Runnable{
    //用Condition实现CountDownLatch功能
    static ReentrantLock reentrantLock = new ReentrantLock();
    static Condition condition = reentrantLock.newCondition();
    static ConditionCountDown conditionCountDown = new ConditionCountDown(10);
    @Override
    public void run() {
        try{
            conditionCountDown.countDown();
            //Thread.sleep(new Random().nextInt(10)*1000);
            System.out.println("check over ,count = "+conditionCountDown.getCount());
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    static class ConditionCountDown{
        //计数器
        int count = 0;
        public ConditionCountDown(int count){
            this.count = count;
        }
        public synchronized void countDown(){
            count--;
            reentrantLock.lock();
            try{
                //线程做完，才signal主线程
                if(count == 0){
                    condition.signal();
                }
            }finally{
                reentrantLock.unlock();
            }
        }
        public synchronized int getCount(){
            return count;
        }
        public void await() throws InterruptedException {
            reentrantLock.lock();
            try{
                //处于等待唤醒状态
                condition.await();
            }finally{
                reentrantLock.unlock();
            }
        }
    }
    public static void main(String args[]) throws InterruptedException {
        ConditionCountDownDemo con = new ConditionCountDownDemo();
        ExecutorService exec = Executors.newFixedThreadPool(10);
        for(int i = 0;i<10;i++){exec.submit(con);}
        conditionCountDown.await();
        System.out.println("notify");
        exec.shutdown();
    }
}