Java多线程之控制执行顺序

概念： 多线程在并发环境中的正常执行顺序是随机无序的，并不能按照期盼的结果输出。

因为启动一个线程时，线程并不会立即执行，而是等待CPU的资源调度，CPU能调度哪个线程，是通过多种复杂的算法计算而来。

（一）Thread的join()方法来解决这个问题

一般在多线程编程时，需要控制线程的先后执行顺序，比如：主线程中写了子线程t1，想要的效果是需要t1先执行，然后再执行接下来的主线程操作，但是默认的是主线程先执行，所以问题就出现了，执行结果与预期结果不一致。

有两个线程t1和t2，现在让t1比t2先执行：

1. Thread t1 = new Thread(new Runnable() {
               @Override
               public void run() {
                  Sysout.out.print("t1");
               }
           });  

1. Thread t2 = new Thread(new Runnable() {
               @Override
               public void run() {
                  try {
                       // 引入t1线程，等待t1线程的run方法执行完 ,t2才会继续执行
                       t1.join();
                   } catch (InterruptedException e) {
                        e.printStackTrace();
                   }
                  Sysout.out.print("t2");
               }
           });

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

执行结果t1 t2

总结:

多线程编程时，可通过join()方法控制线程的先后执行顺序。 join方法：让主线程等待子线程运行结束后再继续运行

（二） 单一线程池 Excutors.newSingleThreadExecutor()

public class Test {
        private static ExecutorService executor = Executors.newSingleThreadExecutor();

        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(new MyThread1());
            Thread t2 = new Thread(new MyThread2());
            Thread t3 = new Thread(new MyThread3());
            executor.submit(t1);
            executor.submit(t2);
            executor.submit(t3);
            executor.shutdown();
        }

}

总结：

利用并发包里的Excutors的newSingleThreadExecutor产生一个单线程的线程池，

而这个线程池的底层原理就是一个先进先出（FIFO）的队列。

代码中executor.submit依次添加了t1 t2 t3线程，按照FIFO的特性，执行顺序也就是t1 t2 t3的执行结果，从而保证了执行顺序。

（三）使用CountDownLatch

final int count = 10; // 计数次数
        final CountDownLatch latch = new CountDownLatch(count);//创建CountDownLatch 实例  预定计数次数:10
        for (int i = 0; i < count; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // do anything
                        System.out.println("线程"
                                + Thread.currentThread().getId());
                    } catch (Throwable e) {
                        // whatever
                    } finally {
                        // 很关键, 无论上面程序是否异常必须执行countDown,否则await无法释放
                        latch.countDown();//递减锁存器的计数，如果计数到达零，则释放所有等待的线程。
                                          // 如果当前计数大于零，则将计数减少 1
                    }
                }
            }).start();
        }
        try {
//             10个线程countDown()都执行之后才会释放当前线程,程序才能继续往后执行
            latch.await();
        } catch (InterruptedException e) {
//             whatever
        }
        System.out.println("Finish");

输出：
线程14
线程13
线程15
线程18
线程20
线程17
线程16
线程22
线程21
线程19
Finish

总结：

java.util.concurrent.CountDownLatch

一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

用给定的计数初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。

到达0之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。

最常见的使用场景: 等待其他线程处理完才继续当前线程。

最重要的是使用非常简单!

参考：https://blog.csdn.net/u013407384/article/details/79999022