多线程控制线程的执行顺序

2021年1月27日 96次阅读来源: 壮子

如何控制线程执行的顺序？

要解决如上的题目，得理解题意的重心在哪。关键词：线程与顺序。

先来一段多线程执行的代码。

public class Test { 
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread1());
        Thread t2 = new Thread(new MyThread2());
        Thread t3 = new Thread(new MyThread3());
        t1.start();
        t2.start();
        t3.start();
    }
}

class MyThread1 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 1");
    }
}

class MyThread2 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 2");
    }
}

class MyThread3 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 3");
    }
}

执行结果我们是完全是可以猜测的，1、2、3线程输出的结果是无序的，因为多线程在并发环境中的正常执行顺序是随机无序的，并不能按照期盼的结果输出。因为启动一个线程时，线程并不会立即执行，而是等待CPU的资源调度，CPU能调度哪个线程，是通过多种复杂的算法计算而来，这里就不展开了。要明确的一点是，多线程运行的随机性。

为了让线程执行的顺序变的可控，将代码作了如下改良：

方法一：join

public class Test { 
    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());
        t1.start();
        t1.join();
        t2.start();
        t2.join();
        t3.start();
    }
}

class MyThread1 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 1");
    }
}

class MyThread2 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 2");
    }
}

class MyThread3 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 3");
    }
}

join方法：让主线程等待子线程运行结束后再继续运行

有了join方法的帮忙，线程123就能按照指定的顺序执行了。

我们来看看示例当中主线程与子线程的执行顺序。在main方法中，先是调用了t1.start方法，启动t1线程，随后调用t1的join方法，main所在的主线程就需要等待t1子线程中的run方法运行完成后才能继续运行，所以主线程卡在t2.start方法之前等待t1程序。等t1运行完后，主线程重新获得主动权，继续运行t2.start和t2.join方法，与t1子线程类似，main主线程等待t2完成后继续执行，如此执行下去，join方法就有效的解决了执行顺序问题。因为在同一个时间点，各个线程是同步状态。

当然解决方法不止一个：

方法二：Excutors.newSingleThreadExecutor()

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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();
    }
}

class MyThread1 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 1");
    }
}

class MyThread2 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 2");
    }
}

class MyThread3 implements Runnable { 
    @Override
    public void run() {
        System.out.println("I am thread 3");
    }
}

利用并发包里的Excutors的newSingleThreadExecutor产生一个单线程的线程池，而这个线程池的底层原理就是一个先进先出（FIFO）的队列。代码中executor.submit依次添加了123线程，按照FIFO的特性，执行顺序也就是123的执行结果，从而保证了执行顺序。

方法三：

java.util.concurrent.CountDownLatch

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

用给定的计数初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前， await 方法会一直受阻塞。到达0之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。

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

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

使用方法3步走:

/**
* step.1
* 创建CountDownLatch 实例预定计数次数:2
*/
CountDownLatch latch = new CountDownLatch(2);

/**
* step.2
* 递减锁存器的计数，如果计数到达零，则释放所有等待的线程。
* 如果当前计数大于零，则将计数减少 1
*/
latch.countDown();

/**
* step.3
* 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断
* 如果当前的计数为零，则此方法立即返回
*/
latch.await();final int count = 10; // 计数次数
final CountDownLatch latch = new CountDownLatch(count);
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();
   }
  }
}).start();
}
try {
// 10个线程countDown()都执行之后才会释放当前线程,程序才能继续往后执行
latch.await();
} catch (InterruptedException e) {
// whatever
}
System.out.println(“Finish”);

    原文作者：壮子
    原文地址: https://blog.csdn.net/u013407384/article/details/79999022
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。