有三个线程T1,T2,T3,如何它们保证顺序执行？_有三个线程t1,t2,t3,怎么确保它们按顺序执行?

目录

一、使用join方法

二、使用CountDownLatch（闭锁）：

三、使用单个线程池：

---

一、使用join方法

        使用 join() 方法可以保证线程的顺序执行。在 Java 中，join() 方法是用来等待一个线程执行完成的方法，当调用某个线程的 join() 方法时，当前线程会被阻塞，直到该线程执行完成后才会继续执行。

具体来说，我们可以在 T1 线程结束时调用 T2 的 join() 方法，这样 T2 就会等待 T1 执行完成后再开始执行；同理，在 T2 结束时调用 T3 的 join() 方法，以确保 T3 在 T2 执行完成后才开始执行。这样就可以保证 T1、T2、T3 按照顺序依次执行。

public class ThreadJoinDemo {
 
    public static void main(String[] args) throws InterruptedException {
 
        Thread t1 = new Thread(() -> System.out.println("t1"));
 
        Thread t2 = new Thread(() -> System.out.println("t2"));
 
        Thread t3 = new Thread(() -> System.out.println("t3"));
 
        t1.start();
        t1.join();  // 等待 t1 执行完成
        t2.start();
        t2.join();  // 等待 t2 执行完成
        t3.start();
        t3.join();  // 等待 t3 执行完成
    }
 
}

二、使用CountDownLatch（闭锁）：

        使用 CountDownLatch（闭锁）方法可以保证线程的顺序执行。CountDownLatch 是一个同步工具类，它可以让某个线程等待多个线程完成各自的工作之后再继续执行。具体来说，我们可以使用两个 CountDownLatch 对象 latch1 和 latch2 分别控制 T1、T2、T3 线程的执行顺序。

初始时，latch1 的计数器为1，latch2 的计数器为2。当 T1 执行完毕时，调用 latch1.countDown() 方法通知 T2 可以开始执行；当 T2 执行完毕时，调用 latch2.countDown() 方法通知 T3 可以开始执行。这样就可以确保 T1、T2、T3 按照顺序依次执行。

在 main 方法中，我们分别启动 T1、T2、T3 线程，然后等待它们执行完毕。需要注意的是，在使用 CountDownLatch 方法时，需要确保计数器的值正确设置，并且每个线程都能够独立执行完成，并且不会相互影响，以避免出现死锁等问题。

        

import java.util.concurrent.CountDownLatch;
 
public class ThreadCountDownLatchDemo {
 
    public static void main(String[] args) throws InterruptedException {
 
        CountDownLatch latch1 = new CountDownLatch(1);
 
        CountDownLatch latch2 = new CountDownLatch(2);
 
        Thread t1 = new Thread(() -> {
            System.out.println("t1");
            latch1.countDown();
        });
    
        Thread t2 = new Thread(() -> {
            try {
                latch1.await();  // 等待 t1 执行完成
                System.out.println("t2");
                latch2.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    
        Thread t3 = new Thread(() -> {
            try {
                latch2.await( ); // 等待 t2 执行完成
                System.out.println("t3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    
        t1.start();
        t2.start();
        t3.start();
    
        t1.join();
        t2.join();
        t3.join();
    }
 
}

三、使用单个线程池：

        使用单个线程池可以保证t1、t2、t3顺序执行，因为单个线程池只有一个工作线程，每次只会执行一个任务。我们可以将t1、t2、t3三个任务按照顺序提交给单个线程池，这样就可以确保它们按照顺序依次执行。

        注意的是，在使用线程池时，需要确保每个任务都能够独立执行完成，并且不会相互影响，以避免出现线程安全等问题。

import java.util.concurrent.ExecutorService;
 
import java.util.concurrent.Executors;
 
public class ThreadOrderDemo {
 
    private static ExecutorService executorService = Executors.newSingleThreadExecutor();
 
    public void t1() {
        System.out.println("t1");
    }
    
    public void t2() {
        System.out.println("t2");
    }
    
    public void t3() {
        System.out.println("t3");
    }
    
    public static void main(String[] args) {
        ThreadOrderDemo demo = new ThreadOrderDemo();
    
        executorService.submit(demo::t1);
        executorService.submit(demo::t2);
        executorService.submit(demo::t3);
    
        executorService.shutdown();
    }
 
}