有三个线程T1,T2,T3,如何它们保证顺序执行？

忘是亡心i 2024-03-22 12:27 40阅读 0赞

**目录**

一、使用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();
        }
    
    }