Java多线程（二）线程的并发工具类

·Fork-Join（暂时省略）：

　　体现了分而治之的思想，就是在必要的情况下，将一个大任务进行拆分（fork）成若干个小人物，再将一个个的小任务的运算结果进行join汇总

常用的并发工具类：

　　·CountDownLatch：

　　　　作用：使一个线程等待其他的线程工作完成以后再执行，可以看成加强版join

　　　　初始化的时候必须要带一个count参数，每执行完一个线程count--，当count=0时

　　　　那些有latch.await()方法的线程才会继续执行

package thread;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

//有五个初始化的线程，有六个扣除点
//扣除完毕以后，主线程和业务线程才能继续自己的工作
public class UseCountDownLatch {

    static CountDownLatch latch = new CountDownLatch(6);

    //初始化线程
    private static class InitThread implements Runnable{
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getId()+
                    "ready init...");
            //表示初始化线程完成工作了
            latch.countDown();
            for (int i = 0; i < 2; i++) {
                System.out.println(Thread.currentThread().getId()+
                        "....working");
            }
        }
    }

    //业务线程，要等待初始化线程结束
    private static class BusThread implements Runnable{
        @Override
        public void run() {
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 3; i++) {
                System.out.println("BusThread"+Thread.currentThread().getId()+
                        "doing business");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //单独的初始化线程,
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.MILLISECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getId()+
                            "ready step1");
                    latch.countDown();//每完成一次初始化操作
                    TimeUnit.MILLISECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getId()+
                            "ready step2");
                    TimeUnit.MILLISECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getId()+
                            "ready step3");
                    latch.countDown();
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(new BusThread()).start();
        for (int i = 0; i < 3; i++) {
            new Thread(new InitThread()).start();
        }
        //所有有await方法的线程都在这里阻塞
        latch.await();
        System.out.println("main now work");
    }
}


·CyclicBarrier：让一组线程到达某个屏障，然后被阻塞，一直到最后这一组内的最后一个线程到达屏障时，屏障开放。
　　构造方法也必须传parties参数，和一个Runnable barrierAction参数，
　　当屏障开放时，BarrierAction定义的任务会被执行。（这个是自己让自己执行）
　　（latch是别人让你执行）