多线程（九）JUC包下的类

1、CountDownLatch（线程计数器 ）

CountDownLatch类位于java.util.concurrent 包下，利用它可以实现类似计数器的功能。比如有一个任务 A，它要等待其他 4 个任务执行完毕之后才能执行，此时就可以利用 CountDownLatch来实现这种功能了。

 

public static void main(String[] args) throws InterruptedException{
    final CountDownLatch latch = new CountDownLatch(4);
    Random random = new Random();
    for (int i = 0; i < 4; i++) {
        new Thread(){
            public void run() {
                System.out.println("学生"+Thread.currentThread().getName()+"正在补作业");
                try {
                    Thread.sleep(random.nextInt(4000)+3000);
                    System.out.println("学生"+Thread.currentThread().getName()+"作业学完，交了作业");
                    latch.countDown();
                    System.out.println("学生"+Thread.currentThread().getName()+"开始做其他事情");
                    Thread.sleep(random.nextInt(4000)+1000);
                    System.out.println("学生"+Thread.currentThread().getName()+"做完自己的事情，回家了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
        }.start();
    }
    latch.await();
    System.out.println("所有学生交完了作业！！");
}

2、CyclicBarrier（回环栅栏-等待至 barrier 状态再全部同时执行）

字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier 可以被重用。我们暂且把这个状态就叫做barrier，当调用 await()方法之后，线程就处于 barrier 了。

 

CyclicBarrier 中最重要的方法就是 await 方法，它有 2 个重载版本：

1. public int await()：用来挂起当前线程，直至所有线程都到达 barrier 状态再同时执行后续任务；
2. public int await(long timeout, TimeUnit unit)：让这些线程等待至一定的时间，如果还有线程没有到达 barrier 状态就直接让到达 barrier 的线程执行后续任务。

public static void main(String[] args) {
    CyclicBarrier cyclicBarrier = new CyclicBarrier(4,()-> System.out.println("所有学生完成作业！"));
    Random random = new Random();
    for (int i = 0; i < 4; i++) {
        new Thread(){
            public void run() {
                System.out.println("学生"+Thread.currentThread().getName()+"正在补作业");
                try {
                    Thread.sleep(random.nextInt(4000)+3000);
                    System.out.println("学生"+Thread.currentThread().getName()+"作业学完，交了作业");
                    cyclicBarrier.await();
                    //完成其他事情的时间，1~5秒
                    System.out.println("学生"+Thread.currentThread().getName()+"开始做其他事情");
                    Thread.sleep(random.nextInt(4000)+1000);
                    System.out.println("学生"+Thread.currentThread().getName()+"做完自己的事情，回家了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            };
        }.start();
    }
}

注意：CountDownLatch 只能使用一次，而 CyclicBarrier 可以使用多次。CountDownLatch 是手动指定等待一个或多个线程执行完成再执行，而 CyclicBarrier 是 n 个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。

 

我觉得这个的不同点是：还是老师收作业的问题，只不过这次条件变成了：现在开始收作业了！要是有一个交不了作业大家都不准走！然后那些交的早的也得等！等所有人都交完作业之后，老师回家做其他事，同学放学回家做其他事！

 

3、Semaphore（信号量-控制同时访问的线程个数）

Semaphore 翻译成字面意思为 信号量，Semaphore 可以控制同时访问的线程个数，通过acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

 

Semaphore 类中比较重要的几个方法：

1. public void acquire(): 用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。
2. public void acquire(int permits):获取 permits 个许可；
3. public void release() { } :释放许可。注意，在释放许可之前，必须先获获得许可。
4. public void release(int permits) { }:释放 permits 个许可；

public class SemaphoreDemo {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(5);
        for (int i = 0; i < 20; i++) {
            final int No = i;
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        //获取许可
                        semaphore.acquire();
                        System.out.println(No);
                        Thread.sleep((long)(Math.random()*10000));
                        //释放
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            exec.execute(runnable);
        }
        exec.shutdown();
    }
}