写一个java线程池的简单应用，主线程需要等待子线程执行完成后输出一句话

可以这样编写：public class SimpleThreadPool {
public static void main(String[] args) {
// 创建线程池
ExecutorService executor = Executors.newFixedThreadPool(5);
// 创建 Runnable 对象任务
Runnable task = () -> {
System.out.println("子线程正在执行……");
};
// 提交任务到线程池
executor.execute(task);
// 关闭线程池
executor.shutdown();
// 等待子线程执行完毕
while (!executor.isTerminated()) {
}
System.out.println("子线程执行完成！");
}
}

相关问题

写一个java线程池的简单应用，主线程需要等待多个子线程执行完成后输出一句话

### 回答1：

下面是一个简单的java线程池应用的例子：public class ThreadPoolExample {
public static void main(String[] args) throws InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(5);
List<Future<String>> futureList = new ArrayList<>();

for (int i = 0; i < 10; i++) {
Future<String> future = executor.submit(() -> {
Thread.sleep(1000);
return "执行完成";
});
futureList.add(future);
}

for (Future<String> future : futureList) {
System.out.println(future.get());
}

System.out.println("所有线程都已完成");
executor.shutdown();
}
}

### 回答2：
在Java中，线程池可以通过Java的ExecutorService接口和ThreadPoolExecutor实现类来创建和管理。下面是一个简单的Java线程池的应用示例：

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建具有固定线程数的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 启动3个子线程进行工作
        executor.submit(new WorkerThread("线程1"));
        executor.submit(new WorkerThread("线程2"));
        executor.submit(new WorkerThread("线程3"));

        // 关闭线程池
        executor.shutdown();

        // 等待所有子线程执行完成后输出一句话
        while (!executor.isTerminated()) {
            // 等待线程池中的任务执行完毕
        }
        System.out.println("所有子线程已经执行完成");
    }

    static class WorkerThread implements Runnable {
        private String threadName;

        public WorkerThread(String threadName) {
            this.threadName = threadName;
        }

        @Override
        public void run() {
            System.out.println("子线程" + threadName + "开始执行");
            try {
                // 子线程的任务
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程" + threadName + "执行完成");
        }
    }
}

该例子中，我们创建了一个固定大小为3的线程池。然后通过submit方法提交了3个工作线程（WorkerThread）的任务给线程池执行。每个工作线程执行任务时，会有2秒的休眠时间模拟实际的工作。

主线程在提交了所有任务后，通过调用线程池的shutdown方法来关闭线程池。然后，在主线程中通过一个循环，检查线程池中的任务是否全部执行完成，直到线程池中所有任务都已完成，才会输出一句话"所有子线程已经执行完成"。

这样就实现了多个子线程执行完成后，主线程输出一句话的需求。

### 回答3：
Java中的线程池是用来管理和复用线程的。下面是一个简单的使用线程池的例子，主线程需要等待多个子线程执行完成之后输出一句话。

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小为3的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 创建3个子线程并提交到线程池执行
        for (int i = 0; i < 3; i++) {
            executor.execute(new MyThread(i));
        }

        // 关闭线程池
        executor.shutdown();

        // 主线程等待所有子线程执行完成
        while (!executor.isTerminated()) {
            // 等待子线程执行完成
        }

        // 输出一句话
        System.out.println("所有子线程执行完成");
    }

    static class MyThread implements Runnable {
        private int id;

        public MyThread(int id) {
            this.id = id;
        }

        @Override
        public void run() {
            System.out.println("子线程 " + id + " 开始执行");
            
            // 子线程执行的任务
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("子线程 " + id + " 执行完成");
        }
    }
}

在这个例子中，我们使用`Executors.newFixedThreadPool(3)`创建了一个固定大小为3的线程池。然后，我们创建了3个子线程，并将它们提交到线程池中执行。

主线程使用`executor.isTerminated()`方法来检查线程池中的所有任务是否都执行完成了。如果没有，则主线程等待。

当所有子线程都执行完成后，主线程输出一句话"所有子线程执行完成"。

注意：这里的线程池的大小为3，并行执行的子线程数量也为3，可以通过增加或减少线程池的大小来控制并发度。

java如何等待线程池的其中一个线程结束，才执行主线程

Java中可以通过使用Future来实现等待线程池中的某个线程结束才执行主线程的操作。具体步骤如下：

1. 创建一个线程池，例如使用Executors.newFixedThreadPool()方法创建一个固定大小的线程池。

2. 将需要执行的任务提交到线程池中，例如使用submit()方法将任务提交到线程池中。

3. 对每个任务都创建一个Future对象，该对象表示任务的执行结果。

4. 使用Future.get()方法来阻塞主线程，等待特定的任务执行完成。

5. 当任意一个任务执行完成后，Future.get()方法返回结果，主线程就可以继续执行了。

示例代码如下：

ExecutorService executor = Executors.newFixedThreadPool(10);
List<Future<?>> futures = new ArrayList<>();

for (int i = 0; i < 10; i++) {
    Future<?> future = executor.submit(new Runnable() {
        public void run() {
            // 执行任务
        }
    });
    futures.add(future);
}

// 等待任意一个任务执行完成
Future<?> completedFuture = executor.invokeAny(futures);

// 执行主线程
System.out.println("任务执行完成：" + completedFuture);

在上面的代码中，我们使用了executor.invokeAny(futures)方法来等待任意一个任务执行完成。该方法会阻塞主线程，直到任意一个任务执行完成并返回结果，然后返回该任务的Future对象。最后，我们打印出任务执行完成的信息，表示主线程可以继续执行了。