2.Java面试题之线程池

1. 写在前面

线程池是一种管理线程的机制，通过预先创建一定数量的线程，可以在需要时重复使用这些线程，从而避免频繁创建和销毁线程带来的性能开销。

使用线程池的优点包括：

• 提高性能：线程池减少了线程创建和销毁的开销。
• 资源管理：线程池控制了线程的数量，避免系统资源耗尽。
• 任务管理：线程池提供了任务队列，可以管理和调度任务的执行。
• 简化编程：线程池提供了一些高级功能，如定时任务、周期性任务等，简化了并发编程。

2. Java 中如何创建线程池？

Java 提供了 java.util.concurrent 包中的 Executors 工具类来创建各种类型的线程池。常见的方法包括：

2.1 固定大小线程池

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);

2.2 缓存线程池

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

2.3 单线程池

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

2.4 定时线程池

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

3. 如何提交任务到线程池？

可以通过 execute 方法或 submit 方法将任务提交到线程池。

3.1 使用 execute 方法

fixedThreadPool.execute(new Runnable() {@Overridepublic void run() {System.out.println("Task executed");}
});

3.2 使用 submit 方法

Future<?> future = fixedThreadPool.submit(new Callable<String>() {@Overridepublic String call() throws Exception {return "Task completed";}
});try {String result = future.get();System.out.println(result);
} catch (InterruptedException | ExecutionException e) {e.printStackTrace();
}

4. 什么是 Future 和 Callable？

Callable 是一个类似于 Runnable 的接口，但它可以返回一个结果或抛出异常。Future 表示一个异步计算的结果，可以用来获取 Callable 的返回值或检查任务是否完成。

Callable<String> callableTask = new Callable<String>() {@Overridepublic String call() throws Exception {return "Task result";}
};Future<String> future = fixedThreadPool.submit(callableTask);try {String result = future.get();  // 阻塞等待任务完成并获取结果System.out.println(result);
} catch (InterruptedException | ExecutionException e) {e.printStackTrace();
}

5. 如何优雅地关闭线程池？

可以使用 shutdown 或 shutdownNow 方法来关闭线程池。

5.1 shutdown 方法

停止接受新任务，并让已提交的任务执行完毕。

fixedThreadPool.shutdown();

5.2 shutdownNow 方法

尝试停止所有正在执行的任务，并返回等待执行的任务列表。

List<Runnable> notExecutedTasks = fixedThreadPool.shutdownNow();

5.3 等待线程池关闭

try {if (!fixedThreadPool.awaitTermination(60, TimeUnit.SECONDS)) {fixedThreadPool.shutdownNow();}
} catch (InterruptedException e) {fixedThreadPool.shutdownNow();
}

6. 线程池的核心参数有哪些？

ThreadPoolExecutor 是 Java 线程池的核心实现类，它的构造函数包含以下参数：

• corePoolSize：核心线程数，即线程池中始终保持的线程数量。
• maximumPoolSize：最大线程数，即线程池中允许的最大线程数量。
• keepAliveTime：非核心线程的空闲时间，超过这个时间将被终止。
• unit：空闲时间的时间单位。
• workQueue：任务队列，用于存储等待执行的任务。
• threadFactory：线程工厂，用于创建新线程。
• handler：拒绝策略，当任务无法执行时的处理方式。

    5,  // corePoolSize10, // maximumPoolSize60, // keepAliveTimeTimeUnit.SECONDS, // unitnew LinkedBlockingQueue<Runnable>(), // workQueueExecutors.defaultThreadFactory(), // threadFactorynew ThreadPoolExecutor.AbortPolicy() // handler
);

7. 线程池的拒绝策略有哪些？

当线程池无法接受新任务时，会使用拒绝策略来处理这些任务。ThreadPoolExecutor 提供了以下几种拒绝策略：

7.1 AbortPolicy

默认策略，抛出 RejectedExecutionException

new ThreadPoolExecutor.AbortPolicy();

7.2 CallerRunsPolicy

由调用线程执行任务

new ThreadPoolExecutor.CallerRunsPolicy();

7.3 DiscardPolicy

直接丢弃任务，不抛出异常。

new ThreadPoolExecutor.DiscardPolicy();

7.4 DiscardOldestPolicy

丢弃队列中最旧的任务，然后尝试重新提交任务。

new ThreadPoolExecutor.DiscardOldestPolicy();

8. 什么是 ForkJoinPool？它与 ThreadPoolExecutor 有什么区别？

ForkJoinPool 是 Java 7 引入的一种特殊的线程池，设计用于处理可以递归拆分成更小任务的并行计算。它基于工作窃取算法，适合处理大规模并行任务。
ForkJoinPool 与 ThreadPoolExecutor 的主要区别在于：

• 任务类型：ForkJoinPool 适用于可以分解的任务，而 ThreadPoolExecutor 适用于独立的任务。
• 工作窃取：ForkJoinPool 使用工作窃取算法，提高了多核 CPU 的利用率，而 ThreadPoolExecutor 使用固定的任务队列。
• API：ForkJoinPool 使用 ForkJoinTask（包括 RecursiveTask 和 RecursiveAction）来表示任务，而 ThreadPoolExecutor 使用 Runnable 和 Callable。

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;class SumTask extends RecursiveTask<Integer> {private final int[] array;private final int start, end;public SumTask(int[] array, int start, int end) {this.array = array;this.start = start;this.end = end;}@Overrideprotected Integer compute() {if (end - start <= 10) {int sum = 0;for (int i = start; i < end; i++) {sum += array[i];}return sum;} else {int mid = (start + end) / 2;SumTask leftTask = new SumTask(array, start, mid);SumTask rightTask = new SumTask(array, mid, end);leftTask.fork();return rightTask.compute() + leftTask.join();}}
}public class ForkJoinExample {public static void main(String[] args) {int[] array = new int[100];for (int i = 0; i < array.length; i++) {array[i] = i + 1;}ForkJoinPool pool = new ForkJoinPool();SumTask task = new SumTask(array, 0, array.length);int result = pool.invoke(task);System.out.println("Sum: " + result);}
}

9. 如何自定义线程池的拒绝策略？

在 ThreadPoolExecutor 中，当线程池和队列都满时，可以自定义拒绝策略来处理新提交的任务。可以通过实现 RejectedExecutionHandler 接口来自定义拒绝策略。

import java.util.concurrent.*;public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {@Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {// 自定义拒绝策略，例如记录日志或将任务放入另一个队列System.out.println("Task " + r.toString() + " rejected from " + executor.toString());}public static void main(String[] args) {ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2),Executors.defaultThreadFactory(),new CustomRejectedExecutionHandler());for (int i = 0; i < 10; i++) {executor.execute(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " is executing task");});}executor.shutdown();}
}

10. 如何实现一个自定义的线程池？

可以通过继承 ThreadPoolExecutor 类来实现一个自定义的线程池，并重写其方法以添加自定义行为。

import java.util.concurrent.*;public class CustomThreadPoolExecutor extends ThreadPoolExecutor {public CustomThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);}@Overrideprotected void beforeExecute(Thread t, Runnable r) {super.beforeExecute(t, r);System.out.println("Before executing task: " + r.toString());}@Overrideprotected void afterExecute(Runnable r, Throwable t) {super.afterExecute(r, t);System.out.println("After executing task: " + r.toString());}@Overrideprotected void terminated() {super.terminated();System.out.println("Thread pool terminated");}public static void main(String[] args) {CustomThreadPoolExecutor executor = new CustomThreadPoolExecutor(2, 4, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2));for (int i = 0; i < 10; i++) {executor.execute(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " is executing task");});}executor.shutdown();}
}

11. 如何实现一个具有动态调整功能的线程池？

可以通过定期调整 ThreadPoolExecutor 的核心参数来实现动态调整线程池的功能。例如，可以使用 ScheduledExecutorService 定期检查任务队列的长度，并根据需要调整核心线程数和最大线程数。

import java.util.concurrent.*;public class DynamicThreadPool {public static void main(String[] args) {ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2));ScheduledExecutorService adjuster = Executors.newScheduledThreadPool(1);adjuster.scheduleAtFixedRate(() -> {int queueSize = executor.getQueue().size();if (queueSize > 2) {executor.setCorePoolSize(Math.min(executor.getCorePoolSize() + 1, 10));executor.setMaximumPoolSize(Math.min(executor.getMaximumPoolSize() + 1, 20));} else if (queueSize == 0) {executor.setCorePoolSize(Math.max(executor.getCorePoolSize() - 1, 2));executor.setMaximumPoolSize(Math.max(executor.getMaximumPoolSize() - 1, 4));}System.out.println("Adjusted Pool Size: " + executor.getCorePoolSize() + ", " + executor.getMaximumPoolSize());}, 0, 1, TimeUnit.SECONDS);for (int i = 0; i < 10; i++) {executor.execute(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " is executing task");});}executor.shutdown();try {executor.awaitTermination(10, TimeUnit.SECONDS);} catch (InterruptedException e) {e.printStackTrace();}adjuster.shutdown();}
}

12. 如何实现一个线程池的优先级队列？

可以使用 PriorityBlockingQueue 来实现一个具有优先级的线程池。任务需要实现 Comparable 接口，以定义任务的优先级。

import java.util.concurrent.*;public class PriorityThreadPool {static class PriorityTask implements Runnable, Comparable<PriorityTask> {private final int priority;private final String name;public PriorityTask(int priority, String name) {this.priority = priority;this.name = name;}@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + " is executing task: " + name);}@Overridepublic int compareTo(PriorityTask o) {return Integer.compare(o.priority, this.priority);}@Overridepublic String toString() {return name + "(priority=" + priority + ")";}}public static void main(String[] args) {ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 60, TimeUnit.SECONDS, new PriorityBlockingQueue<>());for (int i = 0; i < 10; i++) {int priority = i % 3;executor.execute(new PriorityTask(priority, "Task-" + i));}executor.shutdown();}
}

13. 如何实现一个支持超时任务的线程池？

可以使用 ScheduledThreadPoolExecutor 来实现一个支持超时任务的线程池。通过 schedule 方法，可以提交一个带有超时功能的任务。

import java.util.concurrent.*;public class TimeoutThreadPool {public static void main(String[] args) {ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(4);for (int i = 0; i < 10; i++) {ScheduledFuture<?> future = executor.schedule(() -> {try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " is executing task");}, 1, TimeUnit.SECONDS);executor.schedule(() -> {if (!future.isDone()) {future.cancel(true);System.out.println("Task timed out and was cancelled");}}, 3, TimeUnit.SECONDS);}executor.shutdown();}
}