Java 线程池拒绝策略

已于 2024-10-26 23:14:13 修改
阅读量1.4k 收藏 15
点赞数 10
CC 4.0 BY-SA版权
分类专栏： Java 多线程 Java 线程池拒绝策略 文章标签： java
于 2024-10-26 23:11:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34392295/article/details/143261364

文章目录

Java 线程池 ThreadPoolExecutor 拒绝策略

线程池参数

  1. corePoolSize：线程池中的常驻核心线程数。
  2. maximumPoolSize：线程池允许的最大线程数。
  3. keepAliveTime：当线程数大于核心线程数时，多余的空闲线程等待新任务的最大时间。
  4. unit：keepAliveTime的时间单位。
  5. workQueue：任务队列，用于在任务太多时存储多余的任务。
  6. threadFactory：创建线程的工厂，可以设置线程的名字和优先级等。
  7. handler：拒绝策略，当任务太多且队列也满时，如何处理新任务。

1. AbortPolicy（中止策略 - 默认策略）

说明: 不执行新的任务并抛出RejectedExecutionException异常。

应用场景：适用于对系统的稳定性要求较高，不希望丢失任务，但希望能快速发现任务提交失败的情况。

/**
     * A handler for rejected tasks that throws a
     * {@link RejectedExecutionException}.
     *
     * This is the default handler for {@link ThreadPoolExecutor} and
     * {@link ScheduledThreadPoolExecutor}.
     */
    public static class AbortPolicy implements RejectedExecutionHandler {
        /**
         * Creates an {@code AbortPolicy}.
         */
        public AbortPolicy() { }

        /**
         * Always throws RejectedExecutionException.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         * @throws RejectedExecutionException always
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ThreadPoolAbortPolicy {

  private static final AtomicInteger TICKETS = new AtomicInteger(30);

  public static void main(String[] args) {
    try (
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            2,  // 核心线程数
            5,  // 最大线程数
            0L, // 空闲时间
            TimeUnit.SECONDS, // 空闲时间单位
            new LinkedBlockingQueue<>(10),  // 阻塞队列
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy()  // 默认拒绝策略
        )
    ) {
      for (int i = 0; i < 30; i++) {
        threadPoolExecutor.execute(() -> {
          if (TICKETS.get() > 0) {
            System.out.println("===> 售票员: " + Thread.currentThread().getName() + ", 售出票号为: " + TICKETS.getAndDecrement());
          }
        });
      }
    }

    try {
      Thread.sleep(1000);
    }catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      e.printStackTrace();
    }

  }

}

/*
	总共可以售票15张, 因为设置最大线程数为5, 且队列最大的数量为10, 剩下的因为队列已经满了, 所以会被拒绝抛出 RejectedExecutionException.
    
    ===> 售票员: pool-1-thread-4, 售出票号为: 27
    ===> 售票员: pool-1-thread-5, 售出票号为: 26
    ===> 售票员: pool-1-thread-3, 售出票号为: 28
    ===> 售票员: pool-1-thread-1, 售出票号为: 30
    ===> 售票员: pool-1-thread-2, 售出票号为: 29
    ===> 售票员: pool-1-thread-4, 售出票号为: 25
    ===> 售票员: pool-1-thread-5, 售出票号为: 24
    ===> 售票员: pool-1-thread-3, 售出票号为: 23
    ===> 售票员: pool-1-thread-1, 售出票号为: 22
    ===> 售票员: pool-1-thread-2, 售出票号为: 21
    ===> 售票员: pool-1-thread-4, 售出票号为: 20
    ===> 售票员: pool-1-thread-5, 售出票号为: 19
    ===> 售票员: pool-1-thread-3, 售出票号为: 18
    ===> 售票员: pool-1-thread-1, 售出票号为: 17
    ===> 售票员: pool-1-thread-2, 售出票号为: 16
    Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.apollo.pool.ThreadPoolAbortPolicy$$Lambda$14/0x00000008010029f8@9f70c54 rejected from java.util.concurrent.ThreadPoolExecutor@1e67b872[Running, pool size = 5, active threads = 5, queued tasks = 10, completed tasks = 0]
        at java.base/java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2081)
        at java.base/java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:841)
        at 	java.base/java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1376)
        at com.apollo.pool.ThreadPoolAbortPolicy.main(ThreadPoolAbortPolicy.java:26)
*/

2. CallerRunsPolicy（调用者运行策略）

说明: 当任务被拒绝添加时，如果调用者所在的线程不是线程池中的线程，那么任务将由该调用者所在的线程直接执行。

**应用场景：**适用于系统不希望丢弃任务，并且对任务的执行延迟要求不高的情况。当线程池已经饱和时，新任务会在提交任务的线程中执行，可能会导致提交任务的线程阻塞。

 /**
     * A handler for rejected tasks that runs the rejected task
     * directly in the calling thread of the {@code execute} method,
     * unless the executor has been shut down, in which case the task
     * is discarded.
     */
public static class CallerRunsPolicy implements RejectedExecutionHandler {
    /**
         * Creates a {@code CallerRunsPolicy}.
         */
    public CallerRunsPolicy() { }

    /**
         * Executes task r in the caller's thread, unless the executor
         * has been shut down, in which case the task is discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ThreadPoolCallerRunsPolicy {

  private static final AtomicInteger TICKETS = new AtomicInteger(30);

  public static void main(String[] args) {
    try (
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, 5, 0L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(10),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy()
        )
    ) {
      for (int i = 0; i < 30; i++) {
        executor.execute(() ->
            System.out.println("===> 售票员: " + Thread.currentThread().getName() + ", 售出票号为: " + TICKETS.getAndDecrement())
        );
      }
    }

    try {
      Thread.sleep(6000);
    }catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      e.printStackTrace();
    }
    
  }

}


/*
	===> 售票员: pool-1-thread-1, 售出票号为: 30
    ===> 售票员: main, 售出票号为: 29
    ===> 售票员: pool-1-thread-4, 售出票号为: 26
    ===> 售票员: pool-1-thread-3, 售出票号为: 27
    ===> 售票员: pool-1-thread-5, 售出票号为: 25
    ===> 售票员: pool-1-thread-2, 售出票号为: 28
    ===> 售票员: pool-1-thread-1, 售出票号为: 24
    ===> 售票员: main, 售出票号为: 23
    ===> 售票员: pool-1-thread-4, 售出票号为: 22
    ===> 售票员: pool-1-thread-3, 售出票号为: 21
    ===> 售票员: pool-1-thread-5, 售出票号为: 20
    ===> 售票员: pool-1-thread-2, 售出票号为: 19
    ===> 售票员: pool-1-thread-1, 售出票号为: 18
    ===> 售票员: main, 售出票号为: 17
    ===> 售票员: pool-1-thread-4, 售出票号为: 16
    ===> 售票员: pool-1-thread-3, 售出票号为: 15
    ===> 售票员: pool-1-thread-5, 售出票号为: 14
    ===> 售票员: pool-1-thread-5, 售出票号为: 8
    ===> 售票员: pool-1-thread-2, 售出票号为: 13
    ===> 售票员: pool-1-thread-1, 售出票号为: 12
    ===> 售票员: main, 售出票号为: 11
    ===> 售票员: pool-1-thread-4, 售出票号为: 10
    ===> 售票员: pool-1-thread-3, 售出票号为: 9
    ===> 售票员: pool-1-thread-5, 售出票号为: 7
    ===> 售票员: pool-1-thread-2, 售出票号为: 6
    ===> 售票员: pool-1-thread-1, 售出票号为: 5
    ===> 售票员: pool-1-thread-4, 售出票号为: 4
    ===> 售票员: pool-1-thread-3, 售出票号为: 3
    ===> 售票员: pool-1-thread-5, 售出票号为: 2
    ===> 售票员: pool-1-thread-2, 售出票号为: 1
*/

3. DiscardPolicy（丢弃策略）

说明：默默丢弃无法处理的任务，不抛出异常。

应用场景：适用于可以容忍任务丢失的情况，例如不重要的日志处理任务。

/**
     * A handler for rejected tasks that silently discards the
     * rejected task.
     */
public static class DiscardPolicy implements RejectedExecutionHandler {
    /**
         * Creates a {@code DiscardPolicy}.
         */
    public DiscardPolicy() { }

    /**
         * Does nothing, which has the effect of discarding task r.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Function: 线程池拒绝策略 - DiscardPolicy 丢弃任务策略
 */
public class ThreadPoolDiscardPolicy {

  private static final AtomicInteger TICKETS = new AtomicInteger(30);

  public static void main(String[] args) {

    try (
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, 5, 0L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(10),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.DiscardPolicy()
        )
    ) {
      for (int i = 0; i < 30; i++) {
        executor.execute(() ->
            System.out.println("===> 售票员: " + Thread.currentThread().getName() + ", 售出票号为: " + TICKETS.getAndDecrement())
        );
      }
    }

    try {
      Thread.sleep(1000);
    }catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      e.printStackTrace();
    }

  }

}

/*
	===> 售票员: pool-1-thread-5, 售出票号为: 26
    ===> 售票员: pool-1-thread-4, 售出票号为: 27
    ===> 售票员: pool-1-thread-5, 售出票号为: 25
    ===> 售票员: pool-1-thread-4, 售出票号为: 24
    ===> 售票员: pool-1-thread-3, 售出票号为: 28
    ===> 售票员: pool-1-thread-5, 售出票号为: 23
    ===> 售票员: pool-1-thread-1, 售出票号为: 30
    ===> 售票员: pool-1-thread-2, 售出票号为: 29
    ===> 售票员: pool-1-thread-4, 售出票号为: 22
    ===> 售票员: pool-1-thread-3, 售出票号为: 21
    ===> 售票员: pool-1-thread-5, 售出票号为: 20
    ===> 售票员: pool-1-thread-1, 售出票号为: 19
    ===> 售票员: pool-1-thread-2, 售出票号为: 18
    ===> 售票员: pool-1-thread-4, 售出票号为: 17
    ===> 售票员: pool-1-thread-3, 售出票号为: 16
*/

4. DiscardOldestPolicy（丢弃最旧策略）

说明：丢弃任务队列中最旧的未处理任务，然后将新任务加入队列重新尝试执行。

应用场景：适用于任务的重要性相对较低，且希望尽量处理新提交的任务的情况。

/**
     * A handler for rejected tasks that discards the oldest unhandled
     * request and then retries {@code execute}, unless the executor
     * is shut down, in which case the task is discarded. This policy is
     * rarely useful in cases where other threads may be waiting for
     * tasks to terminate, or failures must be recorded. Instead consider
     * using a handler of the form:
     * <pre> {@code
     * new RejectedExecutionHandler() {
     *   public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
     *     Runnable dropped = e.getQueue().poll();
     *     if (dropped instanceof Future<?>) {
     *       ((Future<?>)dropped).cancel(false);
     *       // also consider logging the failure
     *     }
     *     e.execute(r);  // retry
     * }}}</pre>
     */
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    /**
         * Creates a {@code DiscardOldestPolicy} for the given executor.
         */
    public DiscardOldestPolicy() { }

    /**
         * Obtains and ignores the next task that the executor
         * would otherwise execute, if one is immediately available,
         * and then retries execution of task r, unless the executor
         * is shut down, in which case task r is instead discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Function: 线程池拒绝策略 - DiscardOldestPolicy 丢弃最老的任务策略
 */
public class ThreadPoolDiscardOldestPolicy {

  private static final AtomicInteger TICKETS = new AtomicInteger(30);

  public static void main(String[] args) {

    try (
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, 5, 0L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(10),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.DiscardOldestPolicy()
        )
    ) {
      for (int i = 0; i < 30; i++) {
        executor.execute(() ->
            System.out.println("===> 售票员: " + Thread.currentThread().getName() + ", 售出票号为: " + TICKETS.getAndDecrement())
        );
      }
    }

    try {
      Thread.sleep(1000);
    }catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      e.printStackTrace();
    }

  }

}


/*
	===> 售票员: pool-1-thread-2, 售出票号为: 29
    ===> 售票员: pool-1-thread-5, 售出票号为: 26
    ===> 售票员: pool-1-thread-1, 售出票号为: 30
    ===> 售票员: pool-1-thread-4, 售出票号为: 27
    ===> 售票员: pool-1-thread-3, 售出票号为: 28
    ===> 售票员: pool-1-thread-2, 售出票号为: 25
    ===> 售票员: pool-1-thread-5, 售出票号为: 24
    ===> 售票员: pool-1-thread-1, 售出票号为: 23
    ===> 售票员: pool-1-thread-4, 售出票号为: 22
    ===> 售票员: pool-1-thread-3, 售出票号为: 21
    ===> 售票员: pool-1-thread-2, 售出票号为: 20
    ===> 售票员: pool-1-thread-5, 售出票号为: 19
    ===> 售票员: pool-1-thread-1, 售出票号为: 18
    ===> 售票员: pool-1-thread-4, 售出票号为: 17
    ===> 售票员: pool-1-thread-3, 售出票号为: 16
*/

5. 自定义拒绝策略

说明: 需要实现接口 RejectedExecutionHandler, 重写 void rejectedExecution(Runnable r, ThreadPoolExecutor executor) 方法.

package com.apollo.pool;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ThreadPoolSelfDefinePolicy {

  private static final AtomicInteger TICKETS = new AtomicInteger(30);

  public static void main(String[] args) {

    try (
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, 5, 0L, TimeUnit.SECONDS,
           new LinkedBlockingQueue<>(10),
           Executors.defaultThreadFactory(),
           new SelfDefinePolicy()
        )
    ) {
      for (int i = 0; i < 30; i++) {
        executor.execute(() -> {
          if (TICKETS.get() > 0) {
            System.out.println("===> 售票员: " + Thread.currentThread().getName() + ", 售出票号为: " + TICKETS.getAndDecrement());
          }
        });
      }
    }

    try {
      Thread.sleep(1000);
    }catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      e.printStackTrace();
    }


  }

  static class SelfDefinePolicy implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
      // 记录拒绝的任务
      System.out.println("===> 自定义拒绝策略: Task " + r.toString() + " rejected.");
      // 抛出自定义的异常
      throw new RejectedExecutionException("Task " + r + " rejected.");
    }
  }

}

/*
	===> 自定义拒绝策略: Task com.apollo.pool.ThreadPoolSelfDefinePolicy$$Lambda$14/0x0000000801002c10@9f70c54 rejected.
    ===> 售票员: pool-1-thread-2, 售出票号为: 29
    ===> 售票员: pool-1-thread-1, 售出票号为: 30
    ===> 售票员: pool-1-thread-3, 售出票号为: 28
    ===> 售票员: pool-1-thread-5, 售出票号为: 27
    ===> 售票员: pool-1-thread-4, 售出票号为: 26
    ===> 售票员: pool-1-thread-2, 售出票号为: 25
    ===> 售票员: pool-1-thread-1, 售出票号为: 24
    ===> 售票员: pool-1-thread-3, 售出票号为: 23
    ===> 售票员: pool-1-thread-5, 售出票号为: 22
    ===> 售票员: pool-1-thread-4, 售出票号为: 21
    ===> 售票员: pool-1-thread-2, 售出票号为: 20
    ===> 售票员: pool-1-thread-1, 售出票号为: 19
    ===> 售票员: pool-1-thread-3, 售出票号为: 18
    ===> 售票员: pool-1-thread-5, 售出票号为: 17
    ===> 售票员: pool-1-thread-4, 售出票号为: 16
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.apollo.pool.ThreadPoolSelfDefinePolicy$$Lambda$14/0x0000000801002c10@9f70c54 rejected.
	at com.apollo.pool.ThreadPoolSelfDefinePolicy$SelfDefinePolicy.rejectedExecution(ThreadPoolSelfDefinePolicy.java:56)
	at java.base/java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:841)
	at java.base/java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1376)
	at com.apollo.pool.ThreadPoolSelfDefinePolicy.main(ThreadPoolSelfDefinePolicy.java:30)
	
*/
Java线程池拒绝策略深度剖析：4种策略如何选择？
Java大师兄的博客
06-15 922
为什么需要拒绝策略？4种默认拒绝策略的行为差异如何根据业务场景选择策略？自定义拒绝策略的设计思路本文从“生活场景引入→核心概念解释→源码逻辑分析→实战案例验证→场景化选择建议”层层递进，最后总结选择策略的决策树，帮助读者建立系统认知。拒绝策略：线程池处理“超载任务”的应急预案，JDK内置4种策略。触发条件：核心线程满+队列满+达到最大线程数。策略差异。
Java 的线程池中ThreadPoolExecutor 拒绝策略的具体使用
weixin_42551921的博客
05-14 534
如果内置的拒绝策略无法满足需求，可以实现自己的拒绝策略。例如，记录日志、重试任务或将任务保存到数据库。由提交任务的线程（调用者线程）执行被拒绝的任务。丢弃队列中最旧的任务，然后尝试重新提交当前任务。（队列中最旧的任务被丢弃，新任务被重新提交）直接丢弃被拒绝的任务，不抛出异常。（被拒绝的任务不会有任何输出）
Java线程池的拒绝策略
2301_77350672的博客
07-22 2763
拒绝策略被设置为CallerRunsPolicy，即当任务被拒绝时，由提交任务的线程来执行该任务。这是线程池默认的拒绝策略。在这个示例中，我们创建了一个线程池，并设置核心线程数为2，最大线程数为4，使用有界队列（大小为3）。DiscardOldestPolicy：当任务被拒绝时，丢弃队列中最老的一个任务，并尝试再次提交被拒绝的任务。，这意味着当线程池无法处理新的任务时，会丢弃队列中的最早的任务，并尝试将新的任务添加到队列中。，这意味着当线程池无法处理新的任务时，会默默地丢弃被拒绝的任务，不抛出任何异常。
Java线程池深度解析：核心配置与执行策略
最新发布
qq_74898152的博客
09-03 672
实现方式：直接实现RejectedExecutionHandler接口灵活性：可根据业务需求定制特殊的处理逻辑典型应用：任务持久化、转异步处理、降级策略等。
Java线程池的拒绝策略实现详解
08-25
主要介绍了Java线程池的拒绝策略实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java基础：线程池拒绝策略详解
~
08-05 5750
线程池的拒绝策略是指当线程池无法接受新任务时，如何处理这些被拒绝的任务。提供了四种内置的拒绝策略，并且允许用户自定义拒绝策略。除了上述四种内置的拒绝策略外，还允许你通过实现接口来定义自己的拒绝策略。这提供了极高的灵活性，可以根据具体需求定制拒绝任务的行为。自定义拒绝策略示例// 在这里定义你的自定义处理逻辑 System . out . println("Task " + r . toString() + " was rejected");
java线程池拒绝策略
03-17
### Java线程池拒绝策略概述 Java线程池提供了多种内置的拒绝策略来处理任务提交超出线程池容量的情况。这些策略可以通过`ThreadPoolExecutor`类进行设置，具体实现依赖于`RejectedExecutionHandler`接口。 #### ...
java 线程池 拒绝策略
01-25
Java线程池提供了多种机制来处理超出其容量的任务提交情况。当线程池中的任务数量超过核心线程数加上队列的最大长度时，将会触发拒绝策略[^1]。 #### 拒绝策略类型 存在四种主要类型的拒绝策略： - **AbortPolicy...
Java 线程池有哪些拒绝策略？
qq_63553317的博客
02-27 1604
实现方式：实现接口，定义自己的逻辑。示例// 可以记录日志、重试或放入备用队列 } public static void main(String [ ] args) {// 触发自定义策略 executor . shutdown();} }// 可以记录日志、重试或放入备用队列 } public static void main(String [ ] args) {// 触发自定义策略 executor . shutdown();} }
Java 线程池的拒绝策略
CodeFlight
04-18 2723
Java 线程池的拒绝策略一共有四种，分别为`AbortPolicy`，`CallerRunsPolicy`，`DiscardPolicy`，`DiscardOldestPolicy`。下面就来说明这四种策略的不同之处。
Java线程池中的拒绝策略
qq_45537574的博客
12-15 5559
ThreadPoolExecutor 的八种拒绝策略
xiangbole的博客
09-16 3166
前言 谈到java的线程池最熟悉的莫过于ExecutorService接口了，jdk1.5新增的java.util.concurrent包下的这个api，大大的简化了多线程代码的开发。而不论你用FixedThreadPool还是CachedThreadPool其背后实现都是ThreadPoolExecutor。ThreadPoolExecutor是一个典型的缓存池化设计的产物，因为池子有大小，当池...
Java线程池拒绝策略
weixin_39313293的博客
07-18 733
本文介绍了Java线程池的拒绝策略机制。Java提供了四种内置拒绝策略：AbortPolicy（抛出异常）、CallerRunsPolicy（调用者执行）、DiscardPolicy（直接丢弃）和DiscardOldestPolicy（丢弃最旧任务）。默认策略是AbortPolicy。文章还展示了如何自定义拒绝策略（如RequeuePolicy将任务重新入队），并通过示例验证了自定义策略的有效性。
Java线程池的4种拒绝策略
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！✨
08-05 9669
线程池（`ThreadPoolExecutor`）是并发编程中不可或缺的工具，它能够有效地管理线程的生命周期，提高资源利用率，并显著减少线程创建和销毁的开销。然而，当线程池中的线程数达到最大值，且等待队列也已经满了，无法再接受新的任务时，就需要一种策略来处理这些额外的任务，这就是拒绝策略（`RejectedExecutionHandler`）。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值