多线程高级讲解二： jdk1.5并发包提供的 CountDownLatch 和 CyclicBarrier类的await方法（计数器）

CountDownLatch其实特别简单，与join的作用差不多。是jdk1.5的并发包提供的。

比如现在有3个线程，t1、t2、t3， 我现在希望先执行t1，t3，最后才执行t2.。

这时候可以给CountDownLatch设置一个值，比如设置为2，当t1  和 t3执行完毕后，调用CountDownLatch的一个方法，将设置的值2，每次调用，都减1。 当不为0的时候，执行到CountDownLatch的await方法，下面的代码就不执行，然后继续去执行其他线程的方法。直到CountDownLatch设置的值为0的时候，就执行有CountDownLatch的await方法的线程。

注意：如果CountDownLatch设置的值小了，那么只要减到0的时候，await方法下的代码也就可以执行了。

 

public class Test {

    /**
     * 首先说一下，他有什么用 ？
     * <p>
     * 比如，我们创建了3个线程，我们希望t1,t3个线程，先执行。
     * 等前两个线程执行完毕，才执行t2个线程。就可以使用这个类,因为在多线程执行的情况下，是不知道会先执行哪个线程
     * 所以jdk1.5的并发包，就提供了这么一个计数器。就不用自己写了。
     * <p>
     * 与join还是比较类似的。
     */
    public static void main(String[] args) {

        final int MAX = 3;
        /**
         * 后面的2是自定义的，每次运行countDownLatch.countDown()方法后，就减1。
         *
         * 最后一个线程中用countDownLatch.await()方法，意思就是，当其他线程没有执行完毕，就继续等待。
         */
        final CountDownLatch countDownLatch = new CountDownLatch(2);


        Thread t1 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < MAX; i++) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("子线程1....");
                }
                /**
                 * 运行一次这个代码，上面设置的数就减 1
                 */
                countDownLatch.countDown();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            public void run() {

                try {
                    /**
                     * 当CountDownLatch大于0的时候，这里就一直等待
                     */
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < MAX; i++) {
                    System.out.println("子线程2....");
                }
            }
        });

        Thread t3 = new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                for (int i = 0; i < MAX; i++) {
                    System.out.println("子线程3....");
                }
                /**
                 * 运行一次这个代码，上面设置的数就减 1
                 */
                countDownLatch.countDown();
            }
        });

        t1.start();
        t2.start();
        t3.start();


        /**
         *
         * 打印结果：
         *
         * 子线程1....
         * 子线程3....
         * 子线程3....
         * 子线程3....
         * 子线程1....
         * 子线程1....
         * 子线程2....
         * 子线程2....
         * 子线程2....
         *
         * 这样就可以看见 t1 和 t3是交替执行， 执行完毕后才执行t2.
         */

    }
}

 

CyclicBarrier类的await方法，也是放在线程内部，他可以让线程先执行完await方法以上的代码，当所有线程的await以上的代码执行完毕之后，再一起执行await以下的代码。