线程依次执行，交叉执行,各种等待执行，倒计数锁存器

http://www.importnew.com/26850.html

三个线程依次执行，A->B->C

public class ExecutorTest1 {    public static void main(String[] args){        Thread A = new Thread(new Runnable() {            @Override            public void run() {                printNumber("A");            }        });        Thread B = new Thread(new Runnable() {            @Override            public void run() {                try {                    A.join();                    System.out.println("B 等待完 A");                } catch (InterruptedException e) {                    e.printStackTrace();                }                printNumber("B");            }        });        Thread C = new Thread(new Runnable() {            @Override            public void run() {                try {                    B.join();                    System.out.println("C 等待完 B");                } catch (InterruptedException e) {                    e.printStackTrace();                }                printNumber("C");            }        });        C.start();        B.start();        A.start();    }    private static void printNumber(String threadName) {        int i=0;        while (i++ < 100) {//            try {//                Thread.sleep(100);//            } catch (InterruptedException e) {//                e.printStackTrace();//            }            System.out.println(threadName + " print:" + i);        }    }}

两个线程交叉执行

Object lock = new Object();        Thread A = new Thread(new Runnable() {            @Override            public void run() {                synchronized (lock) {                    System.out.println("A 1");                    try {                        lock.wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    System.out.println("A 2");                    System.out.println("A 3");                }            }        });        A.start();        Thread B = new Thread(new Runnable() {            @Override            public void run() {                synchronized (lock) {                    System.out.println("B 1");                    System.out.println("B 2");                    System.out.println("B 3");                    lock.notify();                }            }        });        B.start();

四个线程 A B C D，其中 D 要等到 A B C 全执行完毕后才执行，而且 A B C 是同步运行的

 thread.join()，可以让一个线程等另一个线程运行完毕后再继续执行，那我们可以在 D 线程里依次 join A B C，不过这也就使得 A B C 必须依次执行，而我们要的是这三者能同步运行。

或者说，我们希望达到的目的是：A B C 三个线程同时运行，各自独立运行完后通知 D；对 D 而言，只要 A B C 都运行完了，D 再开始运行。针对这种情况，我们可以利用 CountdownLatch 来实现这类通信方式。它的基本用法是：

1. 创建一个计数器，设置初始值，CountdownLatch countDownLatch = new CountDownLatch(2);
2. 在 等待线程 里调用 countDownLatch.await() 方法，进入等待状态，直到计数值变成 0；
3. 在 其他线程 里，调用 countDownLatch.countDown() 方法，该方法会将计数值减小 1；
4. 当 其他线程 的 countDown() 方法把计数值变成 0 时，等待线程 里的 countDownLatch.await() 立即退出，继续执行下面的代码

注：

java.util.concurrent 
类 CountDownLatch   倒计数锁存器
一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
void await() 
          使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。
 boolean await(long timeout, TimeUnit unit) 
          使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。
 void countDown() 
          递减锁存器的计数，如果计数到达零，则释放所有等待的线程。
 long getCount() 
          返回当前计数。
 String toString() 
          返回标识此锁存器及其状态的字符串。

private static void runDAfterABC() {        int worker = 3;        CountDownLatch countDownLatch = new CountDownLatch(worker);        new Thread(new Runnable() {            @Override            public void run() {                System.out.println("D is waiting for other three threads");                try {                    countDownLatch.await();                    System.out.println("All done, D starts working");                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }).start();        for (char threadName='A'; threadName <= 'C'; threadName++) {            final String tN = String.valueOf(threadName);            new Thread(new Runnable() {                @Override                public void run() {                    System.out.println(tN + "is working");                    try {                        Thread.sleep(100);                    } catch (Exception e) {                        e.printStackTrace();                    }                    System.out.println(tN + "finished");                    countDownLatch.countDown();                }            }).start();        }    }

其实简单点来说，CountDownLatch 就是一个倒计数器，我们把初始计数值设置为3，当 D 运行时，先调用 countDownLatch.await() 检查计数器值是否为 0，若不为 0 则保持等待状态；当A B C 各自运行完后都会利用countDownLatch.countDown()，将倒计数器减 1，当三个都运行完后，计数器被减至 0；此时立即触发 D 的 await() 运行结束，继续向下执行。

因此，CountDownLatch 适用于一个线程去等待多个线程的情况。

三个运动员各自准备，等到三个人都准备好后，再一起跑


上面是一个形象的比喻，针对 线程 A B C 各自开始准备，直到三者都准备完毕，然后再同时运行 。也就是要实现一种 线程之间互相等待 的效果，那应该怎么来实现呢？


上面的 CountDownLatch 可以用来倒计数，但当计数完毕，只有一个线程的 await() 会得到响应，无法让多个线程同时触发。


为了实现线程间互相等待这种需求，我们可以利用 CyclicBarrier 数据结构，它的基本用法是：


先创建一个公共 CyclicBarrier 对象，设置 同时等待 的线程数，CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
这些线程同时开始自己做准备，自身准备完毕后，需要等待别人准备完毕，这时调用 cyclicBarrier.await(); 即可开始等待别人；
当指定的 同时等待 的线程数都调用了 cyclicBarrier.await();时，意味着这些线程都准备完毕好，然后这些线程才 同时继续执行。
实现代码如下，设想有三个跑步运动员，各自准备好后等待其他人，全部准备好后才开始跑：

java.util.concurrent 
类 CyclicBarrier      循环 的 barrier（屏障）

一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。

private static void runABCWhenAllReady() {        int runner = 3;        CyclicBarrier cyclicBarrier = new CyclicBarrier(runner);        final Random random = new Random();        for (char runnerName='A'; runnerName <= 'C'; runnerName++) {            final String rN = String.valueOf(runnerName);            new Thread(new Runnable() {                @Override                public void run() {                    long prepareTime = random.nextInt(10000) + 100;                    System.out.println(rN + "is preparing for time:" + prepareTime);                    try {                        Thread.sleep(prepareTime);                    } catch (Exception e) {                        e.printStackTrace();                    }                    try {                        System.out.println(rN + "is prepared, waiting for others");                        cyclicBarrier.await(); // 当前运动员准备完毕，等待别人准备好                    } catch (InterruptedException e) {                        e.printStackTrace();                    } catch (BrokenBarrierException e) {                        e.printStackTrace();                    }                    System.out.println(rN + "starts running"); // 所有运动员都准备好了，一起开始跑                }            }).start();        }    }