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() {
    @Override
    public void run() {
        System.out.println("Task executed");
    }
});

3.2 使用 submit 方法

Future<?> future = fixedThreadPool.submit(new Callable<String>() {
    @Override
    public 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>() {
    @Override
    public 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,  // corePoolSize
    10, // maximumPoolSize
    60, // keepAliveTime
    TimeUnit.SECONDS, // unit
    new LinkedBlockingQueue<Runnable>(), // workQueue
    Executors.defaultThreadFactory(), // threadFactory
    new 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;
    }

    @Override
    protected 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 {
    @Override
    public 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);
    }

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        System.out.println("Before executing task: " + r.toString());
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        System.out.println("After executing task: " + r.toString());
    }

    @Override
    protected 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;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is executing task: " + name);
        }

        @Override
        public int compareTo(PriorityTask o) {
            return Integer.compare(o.priority, this.priority);
        }

        @Override
        public 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();
    }
}