Concurrent同步工具类01

CountDownLatch介绍

java.util.concurrent.CountDownLatch，我们可以把它看作一个计数器，只不过这个计数器的操作是原子操作，同时只能有一个线程去操作这个计数器，也就是同时只能有一个线程去减这个计数器里面的值。

可以为CountDownLatch对象设置一个初始的数字作为计数值，任何调用这个对象上的await()方法都会阻塞，直到这个计数器的计数值被其他的线程减为0为止。

应用场景

CountDownLatch的一个非常典型的应用场景是：有一个任务A想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如想要继续往下执行的任务A调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个CountDownLatch对象上的countDown()方法，这个调用await()方法的任务A将一直阻塞等待，直到这个CountDownLatch对象的计数值减到0为止。CountDownLatch 以一个给定的数量初始化。countDown() 每被调用一次，这 一数量就减一。

举例：

假设有老板和3个工人的雇佣关系，只有等3个工人的工作完成以后，老板才会结束工作完成情况的检查。

package com.test.lesson01;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo3 {
    public static void main(String[] args) {
        ExecutorService executorService= Executors.newFixedThreadPool(4);
        CountDownLatch countDownLatch=new CountDownLatch(3);
        Worker worker1=new Worker(countDownLatch,"w1");
        Worker worker2=new Worker(countDownLatch,"w2");
        Worker worker3=new Worker(countDownLatch,"w3");
        Boss boss=new Boss(countDownLatch);
        executorService.execute(worker1);
        executorService.execute(worker2);
        executorService.execute(worker3);
        executorService.execute(boss);
        executorService.shutdown();
    }
}



class Worker implements Runnable{
    private CountDownLatch countDownLatch;
    private String name;
    public Worker(CountDownLatch countDownLatch,String name){
        this.countDownLatch=countDownLatch;
        this.name=name;
    }

    @Override
    public void run() {
        try{
            Thread.sleep(1000);
            System.out.println("------开始干活啦-------");
            Thread.sleep(500);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("-----工人"+name+"干活结束----");
        countDownLatch.countDown();
    }
}


class Boss implements Runnable{
    private CountDownLatch countDownLatch;
    public Boss(CountDownLatch countDownLatch){
        this.countDownLatch=countDownLatch;
    }

    @Override
    public void run() {
        System.out.println("老板正在等待所有的工人完工");
        try {
            countDownLatch.await();//等待所有和countDown有关的线程执行完毕后才执行本线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("老板检查工人完工情况结束");
    }
}

运行结果之一为：（工人工作的先后顺序可能每次运行不一致，但是“老板检查工人完工情况结束”一定是最后完成）

老板正在等待所有的工人完工
------开始干活啦-------
------开始干活啦-------
------开始干活啦-------
-----工人w1干活结束----
-----工人w3干活结束----
-----工人w2干活结束----
老板检查工人完工情况结束

 如果上述countDownLatch的初始化数量由3改为5，将会线程阻塞，其中一种运行情况为：