java在多线程中主线程等待子线程运行结束再执行的代码示例

以下是一个Java多线程中主线程等待子线程运行结束再执行的代码示例：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new MyRunnable());
        t.start();
        t.join(); // 等待子线程t执行完毕
        System.out.println("主线程执行完毕");
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("子线程开始执行");
        try {
            Thread.sleep(5000); // 模拟子线程执行耗时操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("子线程执行完毕");
    }
}

在这个示例中，主线程创建并启动了一个子线程t，然后调用t.join()方法等待子线程t执行完毕，最后输出"主线程执行完毕"。子线程t执行了一个模拟耗时操作，然后输出"子线程执行完毕"。

相关问题

java主线程等待子线程

Java中，主线程等待子线程可以使用CountDownLatch或者LockSupport实现。其中CountDownLatch是一个同步工具类，可以让一个或多个线程等待其他线程完成操作，而LockSupport则是一个线程阻塞工具类，可以让线程阻塞和唤醒。

使用CountDownLatch实现主线程等待子线程的示例代码如下：

import java.util.concurrent.CountDownLatch;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(2); // 创建CountDownLatch对象，计数器初始值为2
        new Thread(() -> {
            try {
                System.out.println("子线程1开始执行");
                Thread.sleep(2000); // 模拟子线程1执行任务
                System.out.println("子线程1执行完毕！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                latch.countDown(); // 计数器减1
            }
        }).start();
        new Thread(() -> {
            try {
                System.out.println("子线程2开始执行");
                Thread.sleep(3000); // 模拟子线程2执行任务
                System.out.println("子线程2执行完毕！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                latch.countDown(); // 计数器减1
            }
        }).start();
        latch.await(); // 主线程等待计数器归零
        System.out.println("主线程执行！\ndo something...");
    }
}

使用LockSupport实现主线程等待子线程的示例代码如下：

import java.util.concurrent.locks.LockSupport;

public class Main {
    public static void main(String[] args) {
        Thread mainThread = Thread.currentThread();
        new Thread(() -> {
            try {
                System.out.println("子线程开始执行");
                Thread.sleep(2000); // 模拟子线程执行任务
                System.out.println("子线程执行完毕！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            LockSupport.unpark(mainThread); // 唤醒主线程
        }).start();
        LockSupport.park(); // 主线程阻塞
        System.out.println("主线程执行！\ndo something...");
    }
}

java多线程同时运行，等待任一线程完成后结束所有线程

你可以使用 Java 中的 CountDownLatch 类来实现这个功能。CountDownLatch 是一个同步工具，用于在一个或多个线程等待一组事件发生时等待其他线程。

具体实现方式如下：

1. 创建 CountDownLatch 对象，并将计数器初始化为线程数。

2. 每个线程执行完任务后，调用 CountDownLatch 的 countDown() 方法来减少计数器的值。

3. 在主线程中调用 CountDownLatch 的 await() 方法等待计数器为 0。

4. 当计数器为 0 时，主线程继续执行，结束所有线程。

示例代码如下：

import java.util.concurrent.CountDownLatch;

public class MultiThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        int threadCount = 10;
        CountDownLatch latch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            new Thread(new Task(latch)).start();
        }

        latch.await();
        System.out.println("所有线程执行完成");
    }

    static class Task implements Runnable {
        private CountDownLatch latch;

        public Task(CountDownLatch latch) {
            this.latch = latch;
        }

        @Override
        public void run() {
            // 执行任务
            System.out.println(Thread.currentThread().getName() + "执行任务");
            latch.countDown();
        }
    }
}

在上面的示例代码中，创建了 10 个线程并启动，每个线程执行完任务后，调用 CountDownLatch 的 countDown() 方法，计数器减 1，当计数器为 0 时，主线程从 await() 方法中返回，输出 "所有线程执行完成"。