java三个线程如何做到顺序执行

在 Java 中，要控制三个线程的执行顺序，可以使用多种方法，其中包括使用 synchronized、wait 和 notify 机制，CountDownLatch，CyclicBarrier，以及 Semaphore 等。下面我将展示这些方法的具体实现。

方法一：使用 synchronized、wait 和 notify

public class ThreadSequenceUsingWaitNotify {
    private static final Object lock = new Object();
    private static int turn = 1;

    public static void main(String[] args) {
        Thread t1 = new Thread(new Task(1));
        Thread t2 = new Thread(new Task(2));
        Thread t3 = new Thread(new Task(3));

        t1.start();
        t2.start();
        t3.start();
    }

    static class Task implements Runnable {
        private int threadId;

        public Task(int threadId) {
            this.threadId = threadId;
        }

        @Override
        public void run() {
            synchronized (lock) {
                try {
                    while (turn != threadId) {
                        lock.wait();
                    }
                    System.out.println("Thread " + threadId);
                    turn++;
                    lock.notifyAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

方法二：使用 CountDownLatch

import java.util.concurrent.CountDownLatch;

public class ThreadSequenceUsingCountDownLatch {
    public static void main(String[] args) {
        CountDownLatch latch1 = new CountDownLatch(1);
        CountDownLatch latch2 = new CountDownLatch(1);

        Thread t1 = new Thread(() -> {
            System.out.println("Thread 1");
            latch1.countDown();
        });

        Thread t2 = new Thread(() -> {
            try {
                latch1.await();
                System.out.println("Thread 2");
                latch2.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(() -> {
            try {
                latch2.await();
                System.out.println("Thread 3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t3.start();
        t2.start();
        t1.start();
    }
}

方法三：使用 CyclicBarrier

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class ThreadSequenceUsingCyclicBarrier {
    public static void main(String[] args) {
        CyclicBarrier barrier1 = new CyclicBarrier(2);
        CyclicBarrier barrier2 = new CyclicBarrier(2);

        Thread t1 = new Thread(() -> {
            try {
                System.out.println("Thread 1");
                barrier1.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                barrier1.await();
                System.out.println("Thread 2");
                barrier2.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(() -> {
            try {
                barrier2.await();
                System.out.println("Thread 3");
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

方法四：使用 Semaphore

import java.util.concurrent.Semaphore;

public class ThreadSequenceUsingSemaphore {
    private static final Semaphore semaphore1 = new Semaphore(1);
    private static final Semaphore semaphore2 = new Semaphore(0);
    private static final Semaphore semaphore3 = new Semaphore(0);

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                semaphore1.acquire();
                System.out.println("Thread 1");
                semaphore2.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                semaphore2.acquire();
                System.out.println("Thread 2");
                semaphore3.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(() -> {
            try {
                semaphore3.acquire();
                System.out.println("Thread 3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

这些方法各有优劣，可以根据具体需求选择合适的方式来控制线程的执行顺序。

好的，以下是更多关于控制三个线程执行顺序的方法和详细解释。之前已经介绍了使用 synchronized、wait、notify，CountDownLatch，CyclicBarrier，以及 Semaphore 的方法，下面将继续介绍一些其他方法，并提供更多的上下文和详细解释。

方法五：使用 ReentrantLock 和 Condition

ReentrantLock 提供了更灵活的锁机制，而 Condition 则相当于 Object 的 wait 和 notify 方法。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadSequenceUsingReentrantLock {
    private static final Lock lock = new ReentrantLock();
    private static final Condition condition1 = lock.newCondition();
    private static final Condition condition2 = lock.newCondition();
    private static final Condition condition3 = lock.newCondition();
    private static int turn = 1;

    public static void main(String[] args) {
        Thread t1 = new Thread(new Task(1, condition1, condition2));
        Thread t2 = new Thread(new Task(2, condition2, condition3));
        Thread t3 = new Thread(new Task(3, condition3, condition1));

        t1.start();
        t2.start();
        t3.start();
    }

    static class Task implements Runnable {
        private int threadId;
        private Condition currentCondition;
        private Condition nextCondition;

        public Task(int threadId, Condition currentCondition, Condition nextCondition) {
            this.threadId = threadId;
            this.currentCondition = currentCondition;
            this.nextCondition = nextCondition;
        }

        @Override
        public void run() {
            lock.lock();
            try {
                while (turn != threadId) {
                    currentCondition.await();
                }
                System.out.println("Thread " + threadId);
                turn++;
                nextCondition.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

方法六：使用 Phaser

Phaser 是一个更高级的同步工具，可以用来控制一组线程的执行顺序。

import java.util.concurrent.Phaser;

public class ThreadSequenceUsingPhaser {
    public static void main(String[] args) {
        Phaser phaser = new Phaser(1); // Register self

        new Thread(new Task(phaser, 1)).start();
        new Thread(new Task(phaser, 2)).start();
        new Thread(new Task(phaser, 3)).start();

        phaser.arriveAndDeregister(); // Deregister self
    }

    static class Task implements Runnable {
        private Phaser phaser;
        private int phase;

        public Task(Phaser phaser, int phase) {
            this.phaser = phaser;
            this.phase = phase;
            this.phaser.register(); // Register self
        }

        @Override
        public void run() {
            phaser.arriveAndAwaitAdvance(); // Wait for main thread to deregister
            if (phase == 1) {
                System.out.println("Thread 1");
                phaser.arriveAndAwaitAdvance();
            } else if (phase == 2) {
                phaser.arriveAndAwaitAdvance();
                System.out.println("Thread 2");
                phaser.arriveAndAwaitAdvance();
            } else if (phase == 3) {
                phaser.arriveAndAwaitAdvance();
                phaser.arriveAndAwaitAdvance();
                System.out.println("Thread 3");
            }
        }
    }
}

方法七：使用 Exchanger

Exchanger 是一个同步点，用于在两个线程之间交换数据。虽然不是专门为了控制线程顺序设计的，但可以通过巧妙的使用来实现线程顺序控制。

import java.util.concurrent.Exchanger;

public class ThreadSequenceUsingExchanger {
    private static final Exchanger<String> exchanger1 = new Exchanger<>();
    private static final Exchanger<String> exchanger2 = new Exchanger<>();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                System.out.println("Thread 1");
                exchanger1.exchange("done");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                exchanger1.exchange("start");
                System.out.println("Thread 2");
                exchanger2.exchange("done");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(() -> {
            try {
                exchanger2.exchange("start");
                System.out.println("Thread 3");
            } catch (InterruptedException e

好的，接下来再介绍一些其他方法，用于控制三个线程的执行顺序。

### 方法八：使用 `Join`

`Thread.join()` 方法允许一个线程等待另一个线程完成，下面是简单的实现方式。

```java
public class ThreadSequenceUsingJoin {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> System.out.println("Thread 1"));
        Thread t2 = new Thread(() -> System.out.println("Thread 2"));
        Thread t3 = new Thread(() -> System.out.println("Thread 3"));

        try {
            t1.start();
            t1.join(); // Wait for t1 to finish
            t2.start();
            t2.join(); // Wait for t2 to finish
            t3.start();
            t3.join(); // Wait for t3 to finish
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

方法九：使用 ExecutorService 和 Future

你可以使用 ExecutorService 和 Future 来控制线程的执行顺序。

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

public class ThreadSequenceUsingExecutorService {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        Future<?> future1 = executor.submit(() -> System.out.println("Thread 1"));
        try {
            future1.get(); // Wait for future1 to complete
            Future<?> future2 = executor.submit(() -> System.out.println("Thread 2"));
            future2.get(); // Wait for future2 to complete
            Future<?> future3 = executor.submit(() -> System.out.println("Thread 3"));
            future3.get(); // Wait for future3 to complete
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

方法十：使用 BlockingQueue

使用 BlockingQueue 也可以实现线程的顺序控制，这里用 ArrayBlockingQueue 作为示例。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ThreadSequenceUsingBlockingQueue {
    private static final BlockingQueue<Integer> queue1 = new ArrayBlockingQueue<>(1);
    private static final BlockingQueue<Integer> queue2 = new ArrayBlockingQueue<>(1);

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                System.out.println("Thread 1");
                queue1.put(1); // Signal t2 to run
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                queue1.take(); // Wait for signal from t1
                System.out.println("Thread 2");
                queue2.put(1); // Signal t3 to run
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(() -> {
            try {
                queue2.take(); // Wait for signal from t2
                System.out.println("Thread 3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

方法十一：使用 AtomicInteger

AtomicInteger 可以用于控制线程的执行顺序。

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadSequenceUsingAtomicInteger {
    private static final AtomicInteger counter = new AtomicInteger(1);

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (counter.get() != 1) {}
            System.out.println("Thread 1");
            counter.incrementAndGet();
        });

        Thread t2 = new Thread(() -> {
            while (counter.get() != 2) {}
            System.out.println("Thread 2");
            counter.incrementAndGet();
        });

        Thread t3 = new Thread(() -> {
            while (counter.get() != 3) {}
            System.out.println("Thread 3");
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

方法十二：使用 CompletableFuture

CompletableFuture 提供了一种异步编程模型，可以用来控制线程的执行顺序。

import java.util.concurrent.CompletableFuture;

public class ThreadSequenceUsingCompletableFuture {
    public static void main(String[] args) {
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            System.out.println("Thread 1");
        });

        CompletableFuture<Void> future2 = future1.thenRunAsync(() -> {
            System.out.println("Thread 2");

在实际开发中，选择哪种方法来控制线程的执行顺序主要取决于具体的需求场景和系统的复杂性。下面是对前面提到的几种方法的优缺点分析，以及在实际开发中的应用建议：

### 1. `synchronized`、`wait` 和 `notify`

**优点：**
- 简单直接，适用于基本的线程同步需求。
- 不需要额外的库，JDK 自带。

**缺点：**
- 容易出错，特别是在处理 `wait` 和 `notify` 时需要非常小心。
- 难以调试和维护，尤其在复杂的场景下。

**应用场景：**
- 简单的线程顺序控制，没有高并发需求的场景。

### 2. `CountDownLatch`

**优点：**
- 使用简单，适合一次性的同步。
- 可以确保某些操作在其他操作完成后再执行。

**缺点：**
- `CountDownLatch` 是一次性的，不能重用。

**应用场景：**
- 确保多个线程完成初始化后，再执行某个操作，例如系统启动时的初始化任务。

### 3. `CyclicBarrier`

**优点：**
- 可以重用，适合多次重用的场景。
- 提供了一个可重入的屏障。

**缺点：**
- 相对复杂，理解起来需要一些时间。

**应用场景：**
- 需要在多个线程之间反复同步的场景，例如多阶段计算任务。

### 4. `Semaphore`

**优点：**
- 可以控制多个线程对共享资源的访问。
- 灵活，可用于实现各种复杂的同步需求。

**缺点：**
- 需要仔细设计，避免死锁和资源浪费。

**应用场景：**
- 控制资源访问的并发数量，例如数据库连接池。

### 5. `ReentrantLock` 和 `Condition`

**优点：**
- 提供了比 `synchronized` 更加灵活的锁机制。
- 支持多个条件变量，可以实现复杂的同步逻辑。

**缺点：**
- 代码复杂度较高，需要仔细处理锁的获取和释放。

**应用场景：**
- 需要高度灵活的线程同步，且需要多个条件变量的场景。

### 6. `Phaser`

**优点：**
- 非常灵活，适合动态参与者的场景。
- 支持分层次的同步。

**缺点：**
- 相对复杂，不适合简单场景。

**应用场景：**
- 需要动态调整参与线程的场景，例如复杂的并发任务处理。

### 7. `CompletableFuture`

**优点：**
- 支持异步编程模型，简化异步任务的编写。
- 提供丰富的 API 支持链式调用，非常灵活。

**缺点：**
- 需要理解异步编程模型，学习曲线较陡。

**应用场景：**
- 异步任务处理，特别是需要链式调用和组合的场景。

### 综合建议

在实际开发中，选择哪种方法主要取决于以下几个因素：

1. **简单性**：如果只是简单的线程顺序控制，`CountDownLatch` 或 `synchronized` 等简单的方法就足够了。
2. **灵活性**：如果需要更复杂的控制和灵活性，`ReentrantLock` 和 `Condition` 或 `CompletableFuture` 是更好的选择。
3. **复用性**：如果需要重复使用的同步机制，`CyclicBarrier` 或 `Phaser` 是不错的选择。
4. **异步处理**：如果处理异步任务，`CompletableFuture` 是首选。

总体来说，`CompletableFuture` 在现代 Java 开发中越来越受欢迎，因为它提供了一种简洁且强大的异步编程模型，非常适合处理复杂的异步任务和多线程顺序控制。