java等待线程执行的结果

Java等待线程执行的结果

在多线程编程中，经常会遇到需要等待某个线程执行完成后再继续执行的情况。这时候我们可以利用Java提供的一些工具来实现线程间的等待和通信，以确保线程执行的顺序和结果符合我们的预期。

使用Thread的join方法

Java中的Thread类提供了join方法，可以让一个线程等待另一个线程执行完成后再继续执行。下面是一个简单的示例代码：

public class ThreadJoinExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 is finished");
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 is running");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 is finished");
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("All threads are finished");
    }
}

在这个例子中，我们创建了两个线程thread1和thread2，分别执行一些耗时的操作。在主线程中，我们使用join方法让主线程等待thread1和thread2执行完成后再输出"All threads are finished"。

使用CountDownLatch

除了使用Thread的join方法外，我们还可以使用Java提供的CountDownLatch来实现线程的等待。CountDownLatch是一个同步工具类，可以让一个或多个线程等待其他线程的完成。

下面是一个使用CountDownLatch的示例代码：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(2);

        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 is finished");
            latch.countDown();
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 is running");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 is finished");
            latch.countDown();
        });

        thread1.start();
        thread2.start();

        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("All threads are finished");
    }
}

在这个例子中，我们创建了一个CountDownLatch对象，并将计数器初始化为2。在每个线程执行完成后，调用countDown方法来减少计数器的值。在主线程中，调用await方法来等待计数器的值变为0，然后再输出"All threads are finished"。

序列图

下面是一个使用mermaid语法表示的线程等待执行结果的序列图：

sequenceDiagram
    participant Thread1
    participant Thread2
    participant MainThread

    MainThread ->> Thread1: start
    MainThread ->> Thread2: start
    Thread1 ->> Thread1: sleep 2s
    Thread2 ->> Thread2: sleep 3s
    Thread1 ->> Thread1: finish
    Thread2 ->> Thread2: finish
    MainThread ->> MainThread: wait for threads
    MainThread ->> MainThread: all threads finished

状态图

下面是一个使用mermaid语法表示的线程等待执行结果的状态图：

stateDiagram
    [*] --> Thread1Running
    Thread1Running --> Thread1Finished: sleep 2s
    Thread1Finished --> [*]: finish

    [*] --> Thread2Running
    Thread2Running --> Thread2Finished: sleep 3s
    Thread2Finished --> [*]: finish

    state [*]: Initial State
    state Thread1Running: Thread 1 is running
    state Thread1Finished: Thread 1 is finished
    state Thread2Running: Thread 2 is running
    state Thread2Finished: Thread 2 is finished

通过序列图和状态图，我们可以更直观地了解线程之间的关系和状态变化。

总的来说，Java提供了多种方法来实现线程的等待