并发编程----并发工具类

这些并发过程中使用的工具类较为重要，实际工作中使用比价频繁。

CountDownLatch：
        await(),进入等待的状态；
         countDown(),计数器减一，等待中的线程会恢复；
        应用场景：启动三个线程计算，需要对结果进行累加。

public class countdownLatchDemo {
    public static void main(String[] args) {

        CountDownLatch countDownLatch = new CountDownLatch(8); //传入的是初始的计数器的值

        new Thread(
                ()->{
                    try {
                        countDownLatch.await(); // 只有计数器减去1，这个等待中的线程才会恢复
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("800m比赛结束，清空跑到继续跨栏比赛");
                }
        ,"线程A ").start();

        for(int i =0;i<8;i++){
            int finalI = i;
            new Thread(
                    ()->{
                        try {
                            Thread.sleep(finalI*1000L);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }finally {
                            System.out.println(Thread.currentThread().getName()+"到达终点");
                            countDownLatch.countDown(); // await 在这个countdown之后调用
                        }
                    }
            ).start();
        }
    }
}

CyclicBarrier--栅栏
允许一组线程相互等待达到一个公共的障碍点，之后再继续执行
跟countDownLatch的区别
CountDownLatch一    般用于某个线程等待若干个其他线程执行完任务之后，它才执行；不可重复使用。
CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；可重用的

public class CycleBarrierDemo {

    public static void main(String[] args) {
        // 通过这个类可以实现这几个类都能同步开始，同步结束
        CyclicBarrier cycleBarrier = new CyclicBarrier(8);  // 参数是设置最后需要重复运行的线程数

        for(int i =0;i<8;i++){
            int finalI = i;
            new Thread(
                    ()->{
                        try {
                            Thread.sleep(finalI *1000L);
                            System.out.println(Thread.currentThread().getName()+"准备就绪");
                            cycleBarrier.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } catch (BrokenBarrierException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"就绪完成");
                    }
            ).start();
        }
    }
}

Semaphore--信号量
             控制并发数量， 当并发量达到一定数量后，必须等有的线程结束，其他的线程才能进来
             使用场景：接口限流

public class SemaphoreDemo {

    public static void main(String[] args) {

        Semaphore semaphore = new Semaphore(8);   //参数是所允许的最大线程数

        for(int i=0;i<10;i++){

            int finalI = i;
            new Thread(
                    ()->{
                        try {
                            semaphore.acquire(); // 需要获取这个信号
                            System.out.println(Thread.currentThread().getName()+"开始执行");
                            Thread.sleep(finalI *1000L);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }finally {
                            semaphore.release(); // 执行完毕之后需要释放这个信号量
                        }
                    }
            ).start();
        }
    }
}

Exchanger 用于交换数据
        它提供一个同步点，在这个同步点两个线程可以交换彼此的数据。这两个线程通过exchange方法交换数据，如果第一个线程先执行exchange方法，它会一直等待第二个线程也执exchange，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。因此使用Exchanger的重点是成对的线程使用exchange()方法，当有一对线程达到了同步点，就会进行交换数据。因此该工具类的线程对象是【成对】的。
 

public class ExchangeDemo {

    public static void main(String[] args) {

        Exchanger<String> stringExchanger = new Exchanger<>(); //要求线程数必须是偶数

        String str1 = "jiuye";
        String str2 = "ruxue";

        new Thread(
                ()->{
                    System.out.println(Thread.currentThread().getName()+"初始值是"+str1);
                    try {
                        String exchange = stringExchanger.exchange(str1);
                        System.out.println(Thread.currentThread().getName()+exchange);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
        ,"线程1").start();

        new Thread(
                ()->{
                    System.out.println(Thread.currentThread().getName()+"初始值是str2");
                    try {
                        String exchange = stringExchanger.exchange(str2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                ,"线程2").start();

    }
}