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

83 阅读 0 评论 55 点赞

我是靠谱客的博主自然麦片，最近开发中收集的这篇文章主要介绍线程依次执行，交叉执行,各种等待执行，倒计数锁存器，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

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 来实现这类通信方式。它的基本用法是：

创建一个计数器，设置初始值，CountdownLatch countDownLatch = new CountDownLatch(2);
在等待线程里调用 countDownLatch.await() 方法，进入等待状态，直到计数值变成 0；
在其他线程里，调用 countDownLatch.countDown() 方法，该方法会将计数值减小 1；
当其他线程的 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();
        }
    }