Java线程池的拒绝策略是什么

目录

1. 引言
2. 线程池的基本概念
3. Java中的线程池
4. 线程池的拒绝策略
   • AbortPolicy
   • CallerRunsPolicy
   • DiscardPolicy
   • DiscardOldestPolicy
5. 自定义拒绝策略
6. 线程池拒绝策略的选择
7. 线程池拒绝策略的实践
8. 总结

引言

在多线程编程中，线程池是一种常用的技术，用于管理和复用线程，从而提高程序的性能和资源利用率。然而，当线程池中的线程数量达到上限，并且任务队列也已满时，新的任务将无法被立即处理。此时，线程池需要采取一定的策略来处理这些无法立即执行的任务。这种策略被称为“拒绝策略”。

本文将详细介绍Java线程池的拒绝策略，包括其基本概念、实现方式、适用场景以及如何自定义拒绝策略。通过本文的学习，读者将能够更好地理解和使用Java线程池的拒绝策略，从而提高多线程程序的健壮性和性能。

线程池的基本概念

在深入探讨拒绝策略之前，我们首先需要了解线程池的基本概念。

什么是线程池？

线程池是一种多线程处理形式，它通过预先创建一定数量的线程，并将这些线程放入一个池中，以便在需要时复用这些线程来执行任务。线程池的主要目的是减少线程创建和销毁的开销，从而提高程序的性能。

线程池的组成部分

一个典型的线程池通常由以下几个部分组成：

1. 核心线程数（Core Pool Size）：线程池中始终保持存活的线程数量。
2. 最大线程数（Maximum Pool Size）：线程池中允许存在的最大线程数量。
3. 任务队列（Work Queue）：用于存放待执行任务的队列。
4. 线程工厂（Thread Factory）：用于创建新线程的工厂。
5. 拒绝策略（Rejected Execution Handler）：当线程池和任务队列都满时，用于处理新任务的策略。

Java中的线程池

Java提供了java.util.concurrent包来支持多线程编程，其中ThreadPoolExecutor类是Java线程池的核心实现。通过ThreadPoolExecutor，我们可以创建和管理线程池，并指定不同的参数来满足不同的需求。

创建线程池

在Java中，我们可以通过Executors工厂类来创建不同类型的线程池，例如：

• newFixedThreadPool(int nThreads)：创建一个固定大小的线程池。
• newCachedThreadPool()：创建一个可缓存的线程池，线程池的大小会根据需要自动调整。
• newSingleThreadExecutor()：创建一个单线程的线程池。
• newScheduledThreadPool(int corePoolSize)：创建一个支持定时及周期性任务执行的线程池。

然而，这些工厂方法创建的线程池通常使用默认的参数和拒绝策略。为了更灵活地控制线程池的行为，我们可以直接使用ThreadPoolExecutor类来创建线程池。

ThreadPoolExecutor的构造函数

ThreadPoolExecutor类提供了多个构造函数，其中最常用的一个如下：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

• corePoolSize：核心线程数。
• maximumPoolSize：最大线程数。
• keepAliveTime：非核心线程的空闲存活时间。
• unit：时间单位。
• workQueue：任务队列。
• threadFactory：线程工厂。
• handler：拒绝策略。

通过这个构造函数，我们可以自定义线程池的各个参数，包括拒绝策略。

线程池的拒绝策略

当线程池中的线程数量达到最大线程数，并且任务队列也已满时，新的任务将无法被立即处理。此时，线程池需要采取一定的策略来处理这些无法立即执行的任务。这种策略被称为“拒绝策略”。

Java提供了四种内置的拒绝策略，分别是：

1. AbortPolicy
2. CallerRunsPolicy
3. DiscardPolicy
4. DiscardOldestPolicy

接下来，我们将详细介绍这四种拒绝策略。

AbortPolicy

AbortPolicy是默认的拒绝策略。当线程池和任务队列都满时，AbortPolicy会直接抛出RejectedExecutionException异常，从而阻止新任务的提交。

适用场景

AbortPolicy适用于那些对任务执行失败敏感的场景。例如，在某些关键任务中，如果任务无法被执行，程序需要立即知道并采取相应的措施。

示例代码

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    2, // corePoolSize
    4, // maximumPoolSize
    60, // keepAliveTime
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(2), // workQueue
    new ThreadPoolExecutor.AbortPolicy() // handler
);

for (int i = 0; i < 10; i++) {
    try {
        executor.execute(() -> {
            System.out.println("Task executed by " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    } catch (RejectedExecutionException e) {
        System.out.println("Task rejected: " + e.getMessage());
    }
}

executor.shutdown();

在这个示例中，线程池的核心线程数为2，最大线程数为4，任务队列的容量为2。当我们提交10个任务时，前6个任务会被成功执行，而后4个任务会被拒绝并抛出RejectedExecutionException异常。

CallerRunsPolicy

CallerRunsPolicy是一种较为温和的拒绝策略。当线程池和任务队列都满时，CallerRunsPolicy会将任务回退给调用者，由调用者所在的线程来执行该任务。

适用场景

CallerRunsPolicy适用于那些对任务执行失败不敏感的场景。例如，在某些非关键任务中，如果任务无法被执行，可以由调用者所在的线程来执行，从而避免任务丢失。

示例代码

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    2, // corePoolSize
    4, // maximumPoolSize
    60, // keepAliveTime
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(2), // workQueue
    new ThreadPoolExecutor.CallerRunsPolicy() // handler
);

for (int i = 0; i < 10; i++) {
    executor.execute(() -> {
        System.out.println("Task executed by " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}

executor.shutdown();

在这个示例中，线程池的核心线程数为2，最大线程数为4，任务队列的容量为2。当我们提交10个任务时，前6个任务会被成功执行，而后4个任务会被回退给调用者所在的线程来执行。

DiscardPolicy

DiscardPolicy是一种较为激进的拒绝策略。当线程池和任务队列都满时，DiscardPolicy会直接丢弃新提交的任务，而不做任何处理。

适用场景

DiscardPolicy适用于那些对任务执行失败不敏感的场景。例如，在某些非关键任务中，如果任务无法被执行，可以直接丢弃，而不影响程序的正常运行。

示例代码

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    2, // corePoolSize
    4, // maximumPoolSize
    60, // keepAliveTime
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(2), // workQueue
    new ThreadPoolExecutor.DiscardPolicy() // handler
);

for (int i = 0; i < 10; i++) {
    executor.execute(() -> {
        System.out.println("Task executed by " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}

executor.shutdown();

在这个示例中，线程池的核心线程数为2，最大线程数为4，任务队列的容量为2。当我们提交10个任务时，前6个任务会被成功执行，而后4个任务会被直接丢弃。

DiscardOldestPolicy

DiscardOldestPolicy是一种较为复杂的拒绝策略。当线程池和任务队列都满时，DiscardOldestPolicy会丢弃任务队列中最旧的任务，然后尝试重新提交新任务。

适用场景

DiscardOldestPolicy适用于那些对任务执行失败不敏感的场景。例如，在某些非关键任务中，如果任务无法被执行，可以丢弃最旧的任务，从而为新任务腾出空间。

示例代码

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    2, // corePoolSize
    4, // maximumPoolSize
    60, // keepAliveTime
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(2), // workQueue
    new ThreadPoolExecutor.DiscardOldestPolicy() // handler
);

for (int i = 0; i < 10; i++) {
    executor.execute(() -> {
        System.out.println("Task executed by " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}

executor.shutdown();

在这个示例中，线程池的核心线程数为2，最大线程数为4，任务队列的容量为2。当我们提交10个任务时，前6个任务会被成功执行，而后4个任务中的前2个会被丢弃，最后2个任务会被重新提交并执行。

自定义拒绝策略

除了Java提供的四种内置拒绝策略外，我们还可以通过实现RejectedExecutionHandler接口来自定义拒绝策略。自定义拒绝策略可以满足特定的业务需求，例如记录日志、重试任务等。

实现自定义拒绝策略

要实现自定义拒绝策略，我们需要创建一个类并实现RejectedExecutionHandler接口，然后重写rejectedExecution方法。

示例代码

public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // 记录日志
        System.out.println("Task rejected: " + r.toString());
        
        // 重试任务
        if (!executor.isShutdown()) {
            executor.execute(r);
        }
    }
}

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    2, // corePoolSize
    4, // maximumPoolSize
    60, // keepAliveTime
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(2), // workQueue
    new CustomRejectedExecutionHandler() // handler
);

for (int i = 0; i < 10; i++) {
    executor.execute(() -> {
        System.out.println("Task executed by " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}

executor.shutdown();

在这个示例中，我们创建了一个自定义的拒绝策略CustomRejectedExecutionHandler，在rejectedExecution方法中记录了任务被拒绝的日志，并尝试重新提交任务。通过这种方式，我们可以根据业务需求灵活地处理被拒绝的任务。

线程池拒绝策略的选择

在实际应用中，选择合适的拒绝策略非常重要。不同的拒绝策略适用于不同的场景，选择不当可能会导致程序性能下降或任务丢失。

选择拒绝策略的考虑因素

在选择拒绝策略时，我们需要考虑以下几个因素：

1. 任务的重要性：如果任务非常重要，不能丢失，则应选择AbortPolicy或CallerRunsPolicy；如果任务可以容忍一定的丢失，则可以选择DiscardPolicy或DiscardOldestPolicy。
2. 任务的执行时间：如果任务的执行时间较长，选择CallerRunsPolicy可能会导致调用者线程长时间阻塞，从而影响程序的响应速度。
3. 任务的提交频率：如果任务的提交频率较高，选择DiscardOldestPolicy可能会导致任务队列中的任务频繁被丢弃，从而影响任务的执行顺序。
4. 程序的健壮性：如果程序需要较高的健壮性，应选择AbortPolicy或自定义拒绝策略，以便在任务无法被执行时及时发现问题并采取相应的措施。

拒绝策略的选择建议

根据上述考虑因素，我们可以给出以下选择建议：

• 关键任务：选择AbortPolicy或自定义拒绝策略，确保任务不会丢失。
• 非关键任务：选择DiscardPolicy或DiscardOldestPolicy，避免任务堆积。
• 高并发场景：选择CallerRunsPolicy，避免任务丢失并减轻线程池的压力。
• 低并发场景：选择AbortPolicy或DiscardPolicy，确保任务的执行顺序和完整性。

线程池拒绝策略的实践

在实际开发中，我们需要根据具体的业务需求来选择合适的拒绝策略，并通过实践来验证其效果。以下是一些常见的实践场景和建议。

场景一：高并发任务处理

在高并发场景下，任务的提交频率较高，线程池和任务队列可能会很快达到上限。此时，选择CallerRunsPolicy可以避免任务丢失，并通过调用者线程来执行任务，从而减轻线程池的压力。

示例代码

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    4, // corePoolSize
    8, // maximumPoolSize
    60, // keepAliveTime
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100), // workQueue
    new ThreadPoolExecutor.CallerRunsPolicy() // handler
);

for (int i = 0; i < 1000; i++) {
    executor.execute(() -> {
        System.out.println("Task executed by " + Thread.currentThread().getName());
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}

executor.shutdown();

在这个示例中，我们创建了一个较大的线程池，并选择CallerRunsPolicy作为拒绝策略。通过这种方式，我们可以确保在高并发场景下，任务不会丢失，并且线程池的压力得到有效控制。

场景二：关键任务处理

在处理关键任务时，任务的执行失败可能会导致严重的后果。此时，选择AbortPolicy可以确保任务不会丢失，并通过抛出异常来及时发现问题。

示例代码

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    2, // corePoolSize
    4, // maximumPoolSize
    60, // keepAliveTime
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(2), // workQueue
    new ThreadPoolExecutor.AbortPolicy() // handler
);

for (int i = 0; i < 10; i++) {
    try {
        executor.execute(() -> {
            System.out.println("Task executed by " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    } catch (RejectedExecutionException e) {
        System.out.println("Task rejected: " + e.getMessage());
    }
}

executor.shutdown();

在这个示例中，我们选择AbortPolicy作为拒绝策略，并通过捕获RejectedExecutionException来处理被拒绝的任务。通过这种方式，我们可以确保关键任务不会丢失，并及时发现任务执行失败的问题。

场景三：非关键任务处理

在处理非关键任务时，任务的执行失败不会对程序产生严重影响。此时，选择DiscardPolicy或DiscardOldestPolicy可以避免任务堆积，并确保程序的正常运行。

示例代码

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    2, // corePoolSize
    4, // maximumPoolSize
    60, // keepAliveTime
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(2), // workQueue
    new ThreadPoolExecutor.DiscardOldestPolicy() // handler
);

for (int i = 0; i < 10; i++) {
    executor.execute(() -> {
        System.out.println("Task executed by " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}

executor.shutdown();

在这个示例中，我们选择DiscardOldestPolicy作为拒绝策略，并通过丢弃最旧的任务来为新任务腾出空间。通过这种方式，我们可以确保非关键任务不会堆积，并保持程序的正常运行。

总结

Java线程池的拒绝策略是多线程编程中的重要概念，它决定了当线程池和任务队列都满时，如何处理新提交的任务。Java提供了四种内置的拒绝策略，分别是AbortPolicy、CallerRunsPolicy、DiscardPolicy和DiscardOldestPolicy，每种策略都有其适用的场景。

在实际开发中，我们需要根据具体的业务需求来选择合适的拒绝策略，并通过实践来验证其效果。对于关键任务，应选择AbortPolicy或自定义拒绝策略，确保任务不会丢失；对于非关键任务，可以选择DiscardPolicy或DiscardOldestPolicy，避免任务堆积；在高并发场景下，选择CallerRunsPolicy可以减轻线程池的压力。

通过合理选择和使用拒绝策略，我们可以提高多线程程序的健壮性和性能，从而更好地应对复杂的业务需求。