JUC并发编程（八）：常用辅助类

在并发编程中，Java给我们提供了一些常用的工具类，帮助很好的解决问题，提高性能！

CountDownLatch
首先思考一下这个问题：
在多线程并发环境下，如何实现精确访问控制？

看我的文章的人会知道，使用Condition可以达到精确控制，但是我们有没有其它方法呢？

我们来看一段代码，需求如下：

等待其余六个线程跑完，然后再执行main线程

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch=new CountDownLatch(6);
        for (int i =1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" Start");
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
        countDownLatch.await();//只要计数器没有归零，我们就一直阻塞

        // 想实现的目标：等待上面的6个线程跑完在执行 主线程的 end
        System.out.println(Thread.currentThread().getName() + " End");

    }
}

运行结果如下：

这样看不出来是不是因为CountDownLatch的缘故，所以我们看下用CountDownLatch之前的运行结果

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch=new CountDownLatch(6);
        for (int i =1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" Start");
               // countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
      //  countDownLatch.await();//只要计数器没有归零，我们就一直阻塞

        // 想实现的目标：等待上面的6个线程跑完在执行 主线程的 end
        System.out.println(Thread.currentThread().getName() + " End");

    }
}

我们可以看到没有使用CountDownLatch的时候，main线程总是先执行。

拿我们生活中的关门为例，就能形象的理解它的作用了。

从上面的代码上我们也可以看到，CountDownLatch就两个方法。await 会阻塞等待计数器归零 ， countDown 计数器-1，当计数器变为0的时候，就会放行！也就是当所有的人都出了教室之后才关上门。所以我们如果想让某个线程执行完之后，再执行其它的线程的时候可以用CountDownLatch。

CyclicBarrier
既然有减法计数器，那一定有对应的加法计数器，CyclicBarrier就是加法计数器，我们来看一下它的应用。

小时候看过七龙珠都知道，只有集齐七颗龙珠才可以召唤神龙，我们看下用代码怎么实现：

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功！");
        });

        //集齐龙珠
        for (int i = 1; i <= 7; i++) {
            final int tempInt=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收齐了第"+tempInt+"颗龙珠");
                //线程阻塞1 2 3 4 5 6 7
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

当我们没有集齐看下什么情况：

我们可以看到，当我们只集齐6颗龙珠的时候，程序是一直阻塞在那里。它的原理我们可以看官方的解释
我们可以看到它的核心构造方法，当满足我们设定的parties的值的话，就会触发后面的线程执行。代码中我们没执行一个线程就让它await一次，循环七次之后阻塞的线程数刚好达到我们设置的值，所以会触发后面的线程。

Semaphore
Semaphore是一个信号量，我们生活中随处都可以看见信号量，例如红绿灯，进入车场的指示灯。有了信号量可以很好的管理资源的使用，下面我们以抢车位为例来看下它的用法：

public class SemaphoreDemo {
    public static void main(String[] args) {
        //模拟3个车位
        Semaphore semaphore=new Semaphore(3);

        //模拟6个车
        for (int i =1; i <= 6; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();//获得资源！
                    System.out.println(Thread.currentThread().getName()+"抢到了车位");
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println(Thread.currentThread().getName()+"离开了车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release(); // 释放！
                }
            },String.valueOf(i)).start();

        }
    }
}