在Java中，线程池是一种用于管理多个线程的机制，旨在提高性能并简化多线程编程。Java提供了多种方式来创建和管理线程池，主要通过java.util.concurrent包中的ExecutorService接口和Executors类来实现。以下是几种常见的线程池创建方式：
1. 使用Executors类创建线程池
Executors类提供了一些静态工厂方法来创建常见的线程池类型：
a. Fixed Thread Pool
创建一个固定大小的线程池，当所有线程都在忙时，新任务会在队列中等待。
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
b. Cached Thread Pool
创建一个可缓存的线程池，适合执行很多短期异步任务。线程池根据需要创建新线程，空闲线程会在60秒后被终止和移除。
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
c. Single Thread Executor
创建一个只有一个线程的线程池，确保所有任务按顺序执行。
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
d. Scheduled Thread Pool
创建一个线程池，它可以在给定的延迟后或定期执行任务。
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
2. 使用ThreadPoolExecutor类创建线程池
ThreadPoolExecutor是Java中最灵活的线程池实现，可以自定义线程池的行为。它提供了更多配置选项：
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;ThreadPoolExecutor customThreadPool = new ThreadPoolExecutor(4, // core pool size10, // maximum pool size60, // time to keep idle threads aliveTimeUnit.SECONDS, // time unit for keep alive timenew LinkedBlockingQueue<Runnable>() // work queue
);
3. 使用ForkJoinPool创建线程池
ForkJoinPool是Java 7引入的一个特殊的线程池，适合处理大量小任务的并行执行，尤其适合递归任务。
ForkJoinPool forkJoinPool = new ForkJoinPool();
线程池的关闭
无论使用哪种方式创建线程池，在完成任务后，应该关闭线程池以释放资源：
executorService.shutdown(); // 优雅地关闭，不接受新任务
executorService.shutdownNow(); // 强制关闭，试图终止当前正在执行的任务
线程池创建方式总结
-
Executors类：提供了方便的静态工厂方法来创建常见类型的线程池。newFixedThreadPool(int n): 固定大小线程池。newCachedThreadPool(): 可缓存的线程池。newSingleThreadExecutor(): 单线程池。newScheduledThreadPool(int corePoolSize): 定时线程池。
-
ThreadPoolExecutor类：提供了高度可配置的线程池实现，可以精细控制线程池的行为。 -
ForkJoinPool类：用于并行处理大量小任务，特别是递归任务。
根据应用程序的需求选择合适的线程池实现，可以显著提高性能并简化多线程编程。
案例
这里提供每种线程池的详细案例，帮助你理解它们的使用场景和方式。
1. Fixed Thread Pool
创建一个固定大小的线程池，适合有固定数量线程执行长期任务的场景。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class FixedThreadPoolExample {public static void main(String[] args) {ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);for (int i = 0; i < 10; i++) {final int taskNumber = i;fixedThreadPool.execute(() -> {System.out.println("Task " + taskNumber + " is running by " + Thread.currentThread().getName());try {Thread.sleep(1000); // 模拟任务执行} catch (InterruptedException e) {Thread.currentThread().interrupt();}});}fixedThreadPool.shutdown();}
}
2. Cached Thread Pool
创建一个可缓存的线程池，适合执行大量短期任务。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class CachedThreadPoolExample {public static void main(String[] args) {ExecutorService cachedThreadPool = Executors.newCachedThreadPool();for (int i = 0; i < 10; i++) {final int taskNumber = i;cachedThreadPool.execute(() -> {System.out.println("Task " + taskNumber + " is running by " + Thread.currentThread().getName());try {Thread.sleep(1000); // 模拟任务执行} catch (InterruptedException e) {Thread.currentThread().interrupt();}});}cachedThreadPool.shutdown();}
}
3. Single Thread Executor
创建一个单线程池，适合需要保证任务顺序执行的场景。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class SingleThreadExecutorExample {public static void main(String[] args) {ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();for (int i = 0; i < 10; i++) {final int taskNumber = i;singleThreadExecutor.execute(() -> {System.out.println("Task " + taskNumber + " is running by " + Thread.currentThread().getName());try {Thread.sleep(1000); // 模拟任务执行} catch (InterruptedException e) {Thread.currentThread().interrupt();}});}singleThreadExecutor.shutdown();}
}
4. Scheduled Thread Pool
创建一个定时线程池，适合需要定时或周期性执行任务的场景。
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;public class ScheduledThreadPoolExample {public static void main(String[] args) {ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);Runnable task = () -> {System.out.println("Scheduled task is running by " + Thread.currentThread().getName());};// 定时任务，延迟2秒后执行scheduledThreadPool.schedule(task, 2, TimeUnit.SECONDS);// 周期性任务，延迟1秒后每3秒执行一次scheduledThreadPool.scheduleAtFixedRate(task, 1, 3, TimeUnit.SECONDS);// 允许一些时间让任务执行try {Thread.sleep(10000);} catch (InterruptedException e) {Thread.currentThread().interrupt();}scheduledThreadPool.shutdown();}
}
5. ThreadPoolExecutor
创建一个自定义的线程池，适合需要精细控制线程池行为的场景。
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class CustomThreadPoolExample {public static void main(String[] args) {ThreadPoolExecutor customThreadPool = new ThreadPoolExecutor(4, // core pool size10, // maximum pool size60, // time to keep idle threads aliveTimeUnit.SECONDS, // time unit for keep alive timenew LinkedBlockingQueue<Runnable>() // work queue);for (int i = 0; i < 10; i++) {final int taskNumber = i;customThreadPool.execute(() -> {System.out.println("Task " + taskNumber + " is running by " + Thread.currentThread().getName());try {Thread.sleep(1000); // 模拟任务执行} catch (InterruptedException e) {Thread.currentThread().interrupt();}});}customThreadPool.shutdown();}
}
6. ForkJoinPool
创建一个适合并行处理大量小任务的线程池，特别是递归任务。
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;public class ForkJoinPoolExample {public static void main(String[] args) {ForkJoinPool forkJoinPool = new ForkJoinPool();try {FibonacciTask task = new FibonacciTask(10);Integer result = forkJoinPool.invoke(task);System.out.println("Fibonacci result: " + result);} finally {forkJoinPool.shutdown();}}static class FibonacciTask extends RecursiveTask<Integer> {private final int n;FibonacciTask(int n) {this.n = n;}@Overrideprotected Integer compute() {if (n <= 1) {return n;}FibonacciTask f1 = new FibonacciTask(n - 1);FibonacciTask f2 = new FibonacciTask(n - 2);f1.fork(); // 异步执行return f2.compute() + f1.join(); // 合并结果}}
}
这些示例展示了不同类型线程池的使用方式，根据不同的需求选择合适的线程池类型，可以帮助优化多线程程序的性能和管理复杂度。
![2024年春季学期《算法分析与设计》考前热身练习（历年真题）[纯C语言+思路]](http://pic.xiahunao.cn/2024年春季学期《算法分析与设计》考前热身练习（历年真题）[纯C语言+思路])
