写一个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，可以通过增加或减少线程池的大小来控制并发度。