Java ThreadPoolExecutor 线程池

最新推荐文章于 2024-08-17 10:17:43 发布
最新推荐文章于 2024-08-17 10:17:43 发布
阅读量1.8k 收藏 3
点赞数 1
分类专栏： java 面试 文章标签： 线程池 线程
原文链接：https://www.cnblogs.com/skywang12345/p/3509941.html
版权
java 同时被 2 个专栏收录
69 篇文章 2 订阅
订阅专栏
面试
57 篇文章 4 订阅
订阅专栏

文章目录

概述

ThreadPoolExecutor是线程池类。对于线程池，可以通俗的将它理解为"存放一定数量线程的一个线程集合。线程池允许若个线程同时允许，允许同时运行的线程数量就是线程池的容量；当添加的到线程池中的线程超过它的容量时，会有一部分线程阻塞等待。线程池会通过相应的调度策略和拒绝策略，对添加到线程池中的线程进行管理。"

为什么要用线程池

线程是稀缺资源，它的创建与销毁是一个相对偏重且消耗资源的操作，而Java线程依赖内核线程，创建线程需要进行操作系统状态切换,为了避免资源过度消耗需要设法重用线程执行多个任务，线程池就是一个线程缓存，负责付线程进行统一分配，调优与监控。

在Java中，如果每当一个请求到达就创建一个新线程，开销是相当大的。在实际使用中，每个请求创建新线程的服务器在创建和销毁线程上花费的时间和消耗的系统资源，甚至可能要比花在处理实际的用户请求的时间和资源要多得多。

除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个JVM里创建太多的线程，可能会导致系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，服务器应用程序需要一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务，这就是“池化资源”技术产生的原因。
线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使应用程序响应更快。另外，通过适当地调整线程池中的线程数目可以防止出现资源不足的情况。

使用线程池场景

  • 单个任务处理时间比较短。
  • 需要处理的任务数量很大。

核心方法讲解

ThreadPoolExecutor的数据结构

在这里插入图片描述

// 阻塞队列。
private final BlockingQueue<Runnable> workQueue;
// 互斥锁
private final ReentrantLock mainLock = new ReentrantLock();
// 线程集合。一个Worker对应一个线程。
private final HashSet<Worker> workers = new HashSet<Worker>();
// “终止条件”，与“mainLock”绑定。
private final Condition termination = mainLock.newCondition();
// 线程池中线程数量曾经达到过的最大值。
private int largestPoolSize;
// 已完成任务数量
private long completedTaskCount;
// ThreadFactory对象，用于创建线程。
private volatile ThreadFactory threadFactory;
// 拒绝策略的处理句柄。
private volatile RejectedExecutionHandler handler;
// 保持线程存活时间。
private volatile long keepAliveTime;

private volatile boolean allowCoreThreadTimeOut;
// 核心池大小
private volatile int corePoolSize;
// 最大池大小
private volatile int maximumPoolSize;

workers

workers是HashSet类型，即它是一个Worker集合。而一个Worker对应一个线程，也就是说线程池通过workers包含了"一个线程集合"。当Worker对应的线程池启动时，它会执行线程池中的任务；当执行完一个任务后，它会从线程池的阻塞队列中取出一个阻塞的任务来继续运行。
wokers的作用是，线程池通过它实现了"允许多个线程同时运行"。

workQueue

workQueue是BlockingQueue类型，即它是一个阻塞队列。当线程池中的线程数超过它的容量的时候，线程会进入阻塞队列进行阻塞等待。
通过workQueue，线程池实现了阻塞功能。

corePoolSize和maximumPoolSize

corePoolSize是"核心池大小"，maximumPoolSize是"最大池大小"。它们的作用是调整"线程池中实际运行的线程的数量"。
例如，当新任务提交给线程池时(通过execute方法)。
如果此时，线程池中运行的线程数量< corePoolSize，则创建新线程来处理请求。
如果此时，线程池中运行的线程数量> corePoolSize，但是却< maximumPoolSize；则仅当阻塞队列满时才创建新线程。
如果设置的 corePoolSize 和 maximumPoolSize 相同，则创建了固定大小的线程池。如果将 maximumPoolSize 设置为基本的无界值（如 Integer.MAX_VALUE），则允许池适应任意数量的并发任务。在大多数情况下，核心池大小和最大池大小的值是在创建线程池设置的；但是，也可以使用 setCorePoolSize(int) 和 setMaximumPoolSize(int) 进行动态更改。

poolSize

poolSize是当前线程池的实际大小，即线程池中任务的数量。

allowCoreThreadTimeOut和keepAliveTime

allowCoreThreadTimeOut表示是否允许"线程在空闲状态时，仍然能够存活"；而keepAliveTime是当线程池处于空闲状态的时候，超过keepAliveTime时间之后，空闲的线程会被终止。

threadFactory

threadFactory是ThreadFactory对象。它是一个线程工厂类，“线程池通过ThreadFactory创建线程”。

handler

handler是RejectedExecutionHandler类型。它是"线程池拒绝策略"的句柄，也就是说"当某任务添加到线程池中，而线程池拒绝该任务时，线程池会通过handler进行相应的处理"。
在这里插入图片描述
在这里插入图片描述
说明：
在"图-01"中，线程池中有N个任务。“任务1”, “任务2”, "任务3"这3个任务在执行，而"任务3"到"任务N"在阻塞队列中等待。正在执行的任务，在workers集合中，workers集合包含3个Worker，每一个Worker对应一个Thread线程，Thread线程每次处理一个任务。
当workers集合中处理完某一个任务之后，会从阻塞队列中取出一个任务来继续执行，如图-02所示。图-02表示"任务1"处理完毕之后，线程池将"任务4"从阻塞队列中取出，放到workers中进行处理。

ThreadPoolExecutor最核心的构造方法

public ThreadPoolExecutor(int corePoolSize,  
                              int maximumPoolSize,  
                              long keepAliveTime,  
                              TimeUnit unit,  
                              BlockingQueue<Runnable> workQueue,  
                              ThreadFactory threadFactory,  
                              RejectedExecutionHandler handler) {  
        if (corePoolSize < 0 ||  
            maximumPoolSize <= 0 ||  
            maximumPoolSize < corePoolSize ||  
            keepAliveTime < 0)  
            throw new IllegalArgumentException();  
        if (workQueue == null || threadFactory == null || handler == null)  
            throw new NullPointerException();  
        this.corePoolSize = corePoolSize;  
        this.maximumPoolSize = maximumPoolSize;  
        this.workQueue = workQueue;  
        this.keepAliveTime = unit.toNanos(keepAliveTime);  
        this.threadFactory = threadFactory;  
        this.handler = handler;  
    }

构造方法参数讲解

参数名字作用
corePoolSize核心线程池大小
maximumPoolSize最大线程池大小
keepAliveTime线程池中超过corePoolSize数目的空闲线程最大存活时间；可以allowCoreThreadTimeOut(true)使得核心线程有效时间
TimeUnitkeepAliveTime时间单位
workQueue阻塞任务队列
threadFactory新建线程工厂
RejectedExecutionHandler当提交任务数超过maxmumPoolSize+workQueue之和时，任务会交给RejectedExecutionHandler来处理

其中比较容易让人误解的是：corePoolSize，maximumPoolSize，workQueue之间关系。
一个任务(即调用的一个方法)通过 execute(Runnable)方法被添加到线程池，任务就是一个 Runnable类型的对象，任务的执行方法就是Runnable类型对象的run()方法。

当一个任务通过execute(Runnable)方法欲添加到线程池时：

1.当线程池中运行的线程数量<corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程 （有空闲也新建）
2.当线程池达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行
3.当workQueue已满，且maximumPoolSize>corePoolSize时（此时workQueue已满），新提交任务会创建新线程执行任务
4.当线程池中运行的线程数量>maximumPoolSize时，新提交任务由RejectedExecutionHandler处理
5.当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程
6.当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭

线程管理机制图示：
点击查看原始大小图片
在这里插入图片描述

Executors提供的线程池配置方案

newFixedThreadPool固定线程数目的线程池

配置的corePoolSize与maximumPoolSize大小相同，同时使用了一个无界LinkedBlockingQueue存放阻塞任务(队列大小Integer.MAX_VALUE，有可能内存溢出)，因此多余的任务将存在再阻塞队列，不会由RejectedExecutionHandler处理。 

public static ExecutorService newFixedThreadPool(int nThreads) {  
return new ThreadPoolExecutor(nThreads, nThreads,   0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());  
    }

LinkedBlockingQueue

LinkedBlockingQueue是无界的，是一个无界缓存的等待队列。
基于链表的阻塞队列，内部维持着一个数据缓冲队列（该队列由链表构成）。当生产者往队列中放入一个数据时，队列会从生产者手中获取数据，并缓存在队列内部，而生产者立即返回；只有当队列缓冲区达到最大值缓存容量时（LinkedBlockingQueue可以通过构造函数指定该值），才会阻塞生产者队列，直到消费者从队列中消费掉一份数据，生产者线程会被唤醒，反之对于消费者这端的处理也基于同样的原理。
LinkedBlockingQueue之所以能够高效的处理并发数据，还因为其对于生产者端和消费者端分别采用了独立的锁来控制数据同步，这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。

LinkedBlockingDeque

是一个由链表结构组成的双向阻塞队列，即可以从队列的两端插入和移除元素。双向队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。

newCachedThreadPool无缓冲功能的线程池(SynchronousQueue)

SynchronousQueue，因此任务提交之后，将会创建新的线程执行；线程空闲超过60s将会销毁

public static ExecutorService newCachedThreadPool() {  
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());  
    }

当使用SynchronousQueue队列的时候，maximumPoolSize应该设置的略大一些，最大值取决于同时提交任务的最大数。
使用SynchronousQueue的时候，因为当activeCount达到maximumPoolSize的时候，再有任务进来就会发生Reject。因此maximumPoolSize可以设置大一些，那么设置多大呢？我们可以通过检测activeCount/maximumPoolSize的值来决定是否需要将maximumPoolSize的值调整的大一些，而这一时刻可以通过报警告知我们。
newCachedThreadPool缺点 非核心线程数 Integer.MAX_VALUE，容易造成CPU 100%，有可能OOM。

public class ThreadPoolCached {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        //当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程
//        ExecutorService cachedThreadPool = Executors.newFixedThreadPool(5);
//        ExecutorService cachedThreadPool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            try {
//                System.out.println(index + "当前线程1" + Thread.currentThread().getName());
                //newCachedThreadPool  不sleep 会使用多个线程，任务长会将使用完的线程重新利用,而不是新建线程
                Thread.sleep(index * 100);
            } catch (Exception e) {
                e.printStackTrace();
            }

            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(index + "当前线程" + Thread.currentThread().getName());
                }
            });
        }
        cachedThreadPool.shutdown();

    }
}

在这里插入图片描述
发现10个线程都是使用的线程1，线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程，让之前线程空闲。

SynchronousQueue 内部没有容量，但是由于一个插入操作总是对应一个移除操作，反过来同样需要满足。那么一个元素就不会再SynchronousQueue 里面长时间停留，一旦有了插入线程和移除线程，元素很快就从插入线程移交给移除线程。也就是说这更像是一种信道（管道），资源从一个方向快速传递到另一方向。显然这是一种快速传递元素的方式，也就是说在这种情况下元素总是以最快的方式从插入着（生产者）传递给移除着（消费者），这在多任务队列中是最快处理任务的方式。在线程池里的一个典型应用是newCachedThreadPool()就使用了SynchronousQueue，这个线程池根据需要（新任务到来时）创建新的线程，如果有空闲线程则会重复使用，线程空闲了60秒后会被回收。
可以这样来理解：生产者和消费者互相等待对方，握手，然后一起离开。

newSingleThreadExecutor一个线程的线程池

配置corePoolSize=maximumPoolSize=1，无界阻塞队列LinkedBlockingQueue(大小Integer.MAX_VALUE，有可能OOM )；保证任务由一个线程串行执行

public static ExecutorService newSingleThreadExecutor() {  
        return new FinalizableDelegatedExecutorService  
            (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,   new LinkedBlockingQueue<Runnable>()));  
    }

newScheduledThreadPool定时功能的线程池

配置corePoolSize，无界延迟阻塞队列DelayedWorkQueue；有意思的是：maximumPoolSize=Integer.MAX_VALUE，由于DelayedWorkQueue是无界队列，所以这个值是没有意义的。

public class ScheduledThreadPoolTest {
    public static void main(String[] args) throws InterruptedException {
        // 创建大小为5的线程池
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

        for (int i = 0; i < 3; i++) {
            Task worker = new Task("task-" + i);
            // 只执行一次
//          scheduledThreadPool.schedule(worker, 5, TimeUnit.SECONDS);
            // 周期性执行，每5秒执行一次，直到主线程里线程池shutdown()
            scheduledThreadPool.scheduleAtFixedRate(worker, 0,8, TimeUnit.SECONDS);
        }

        Thread.sleep(10000);

        System.out.println("Shutting down executor...");
        // 关闭线程池
        scheduledThreadPool.shutdown();
        boolean isDone;
        // 等待线程池终止
        do {
            isDone = scheduledThreadPool.awaitTermination(1, TimeUnit.DAYS);
            System.out.println("awaitTermination...");
        } while(!isDone);

        System.out.println("Finished all threads");
    }
}

线程池5种状态

线程池的5种状态：Running、ShutDown、Stop、Tidying、Terminated。

线程池各个状态切换框架图：
在这里插入图片描述

1. RUNNING

(1) 状态说明：线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行处理。
(2) 状态切换：线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0！

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

2. SHUTDOWN

(1) 状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。
(2) 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。

3. STOP

(1) 状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
(2) 状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP。

4. TIDYING

(1) 状态说明：当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
(2) 状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。
当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。

5. TERMINATED

(1) 状态说明：线程池彻底终止，就变成TERMINATED状态。
(2) 状态切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

排队策略

排队有三种通用策略：

  • 直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
  • 无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列
  • 有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。 如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。

拒绝策略

AbortPolicy （默认）

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
这是线程池默认的拒绝策略，在任务不能再提交的时候，抛出异常，及时反馈程序运行状态。如果是比较关键的业务，推荐使用此拒绝策略，这样子在系统不能承载更大的并发量的时候，能够及时的通过异常发现。

DiscardPolicy

ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。如果线程队列已满，则后续提交的任务都会被丢弃，且是静默丢弃。

使用此策略，可能会使我们无法发现系统的异常状态。建议是一些无关紧要的业务采用此策略。例如，博客网站统计阅读量就是采用的这种拒绝策略。

DiscardOldestPolicy

ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务。
此拒绝策略，是一种喜新厌旧的拒绝策略。是否要采用此种拒绝策略，还得根据实际业务是否允许丢弃老任务来认真衡量。

CallerRunsPolicy

ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
如果任务被拒绝了，则由调用线程（提交任务的线程）直接执行此任务.

如何设置参数

如何来设置

需要根据几个值来决定
tasks ：每秒的任务数，假设为500~1000
taskcost：每个任务花费时间，假设为0.1s
responsetime：系统允许容忍的最大响应时间，假设为1s

做几个计算

corePoolSize = 每秒需要多少个线程处理？
threadcount = tasks/(1/taskcost) =tasks*taskcost = (500~1000)*0.1 = 50~100 个线程。corePoolSize设置应该大于50
根据8020原则，如果80%的每秒任务数小于800，那么corePoolSize设置为80即可
queueCapacity = (coreSizePool/taskcost)responsetime
计算可得 queueCapacity = 80/0.11 = 80。意思是队列里的线程可以等待1s，超过了的需要新开线程来执行
切记不能设置为Integer.MAX_VALUE，这样队列会很大，线程数只会保持在corePoolSize大小，当任务陡增时，不能新开线程来执行，响应时间会随之陡增。
maxPoolSize = (max(tasks)- queueCapacity)/(1/taskcost)
计算可得 maxPoolSize = (1000-80)/10 = 92
（最大任务数-队列容量）/每个线程每秒处理能力 = 最大线程数
rejectedExecutionHandler：根据具体情况来决定，任务不重要可丢弃，任务重要则要利用一些缓冲机制来处理
keepAliveTime和allowCoreThreadTimeout采用默认通常能满足
以上都是理想值，实际情况下要根据机器性能来决定。如果在未达到最大线程数的情况机器cpu load已经满了，则需要通过升级硬件（呵呵）和优化代码，降低taskcost来处理。

总结

  1. 用ThreadPoolExecutor自定义线程池，看线程的用途，如果任务量不大，可以用无界队列，如果任务量非常大，要用有界队列，防止OOM(out of memory)
  2. 当使用有界队列的时候，corePoolSize设置的应该尽可能和maximumPoolSize相等。使用有界队列的时候，因为只有当队列满的时候才会创建大于corePoolSize大小的线程数，而队列有任务堆积已经意味着当前线程池中的工作线程处于过载状态，我们需要关注这个事件，而maximumPoolSize就基本没有用了，因此我们建议当使用有界队列的时候，corePoolSize的大小可以和maximumPoolSize的大小相等。
  3. 如果任务量很大，还要求每个任务都处理成功，要对提交的任务进行阻塞提交，重写拒绝机制，改为阻塞提交。保证不抛弃一个任务
  4. 最大线程数一般设为2N+1最好，N是CPU核数 （Intel 赛扬G460是单核心，双线程的CPU，Intel 酷睿i3 3220是双核心 四线程，Intel 酷睿i7 4770K是四核心 八线程 ，Intel 酷睿i5 4570是四核心 四线程等等）
  5. 核心线程数，看应用，如果是任务，一天跑一次，设置为0，合适，因为跑完就停掉了，如果是常用线程池，看任务量，是保留一个核心还是几个核心线程数
  6. 如果要获取任务执行结果，用CompletionService，但是注意，获取任务的结果的要重新开一个线程获取，如果在主线程获取，就要等任务都提交后才获取，就会阻塞大量任务结果，队列过大OOM(out of memory)，所以最好异步开个线程获取结果。

Java线程池优点

  1. 重用存在的线程，减少线程创建，消亡的开销，提高性能。
  2. 提高响应速度，当任务到达时，任务可以不需要等到线程创建就能立即执行。
  3. 提高线程的可管理性，可统一分配，调优和监控。

Java线程池缺点

非核心线程创建时机

非核心线程在队列满时触发创建，在瞬时冲高情况下，队列被占满，但新创建的线程来不及消费等待队列中的任务，新任务被拒绝。
举个例子，假设有一个线程池corePoolSize=1，maximumPoolSize=2，队列长度为10。在绝大多数情况下，添加任务的速度为每5秒1条，单任务处理时间为1秒，此时线程池中只有一个核心线程。但某个时间段内，任务生产速度增加，每秒钟任务添加速度增长为每500ms添加1条，单任务处理时间不变，持续时间为10分钟。基于当前的策略，行为如下：

等待队列中任务开始累积，10秒后任务队列满。
第11秒，创建一个新线程处理新任务，第11.5秒新任务到来，此时2个线程均处于busy状态，此时任务丢弃。之后队列始终处于满状态，由于调度时差任务可能进一步丢失。10分钟后开始队列逐步被清空。
这里举了最简单的场景，此场景下始终处于满队列状态，现实中瞬时冲高要比示例中的更复杂，包括任务添加频率不固定，每个任务处理时间的随机性等。

排队任务调度策略

任务的执行顺序和任务的添加顺序是不一致的，即任务优先级和执行优先级不一致，这可能导致务堵塞。
为阐述方便，本节先定义一个最简配置线程池配置如下：
核心线程数：1。
队列大小：10。
最大线程数：2。

非核心线程在队列满时触发创建，并执行当前的任务，但队列中的任务依旧处于排队状态。举例说明：
当前核心线程已满，队列(队列大小为10)中处于排队的任务编号分别为任务20-29。
当任务30到来时，队列插入失败，创建新线程，此时新线程处理任务30，而非任务20。

原理
在这里插入图片描述

参考：
https://www.cnblogs.com/skywang12345/p/3509941.html (Java多线程系列–“JUC线程池”02之 线程池原理(一))
https://www.cnblogs.com/duanxz/p/3252267.html (阻塞队列之三：SynchronousQueue同步队列 阻塞算法的3种实现)
https://blog.csdn.net/q438944209/article/details/82923024 （线程池的使用（newCachedThreadPool））
https://www.cnblogs.com/feiyun126/p/7686302.html (ThreadPoolExecutor的三种队列SynchronousQueue，LinkedBlockingQueue，ArrayBlockingQueue)
https://www.jianshu.com/p/896b8e18501b （Java线程池分析及策略优化）
http://825635381.iteye.com/blog/2184680
http://blog.csdn.net/wangwenhui11/article/details/6760474
http://blog.csdn.net/mccand1234/article/details/51972820
http://blog.csdn.net/yu132563/article/details/45222935
https://www.cnblogs.com/waytobestcoder/p/5323130.html （ThreadPoolExecutor线程池参数设置技巧）

春天的早晨
关注
专栏目录
java ThreadPoolExecutor线程池执行逻辑
qq_34396672的博客
10-03 225
ThreadPoolExecutor线程池执行线程源码解析
Java线程池ThreadPoolExecutor极简教程
m0_71563599的博客
06-04 384
ThreadPoolExecutor 是 java.util.concurrent 包下的一个类，在jdk1.5版本引入，帮助开发人员管理线程并方便地执行并行任务。通俗来说，ThreadPoolExecutor 的作用是生产和管理线程池的，可以通过调用其 execute 方法和 submit 方法执行多线程任务。ExecutorService 对象和 ThreadPoolExecutor 的关系如下图：ExecutorServiceConfig： package com.ramble.threadpool.
java ThreadPoolExecutor使用方法简单介绍
08-31
主要介绍了java ThreadPoolExecutor使用方法简单介绍的相关资料,需要的朋友可以参考下
Java多线程之~~~使用ThreadPoolExecutor来创建线程
iteye_2022的博客
09-23 201
以前我们创建线程的时候都是主动的new一个Thread，然后调用他们的start方法，但是如果线程非常多，任务也非 常多的时候，这样写就会显得非常麻烦，当然可能效率也不是很高，Java给我们提供了叫线程创建器这个样概念的类， 他可以帮助我们管理这些线程，你做的就是编写好代码，然后交给他，她就会自动帮你运行。 当然，带cache的threadpool 对于死掉的线程重新调用，在性能上也会有非常...
Java并发编程 - 线程池ThreadPoolExecutor详解
最新发布
qq_33240556的博客
08-17 813
是Java中实现线程池的一种强大工具，它可以灵活地配置线程池的各种参数，以适应不同的应用场景。合理配置线程池可以显著提高系统的响应速度和吞吐量，同时减少资源消耗。在设计线程池时，应该根据具体的需求仔细考虑各种参数的选择，以确保线程池能够高效稳定地运行。
Java ThreadPoolExecutor的使用
weixin_33781606的博客
11-21 56
今天在搭建项目框架的时候使用到了该类，也写了点测试代码，在此供需要的朋友参考。/*** 内部消息出传送对象,单例对象.* 注意：如果是多线程在处理，那么对于那种有明确先后处理次序的消息不能使用。* */public class InnerMsgTransfer {private static InnerMsgTransfer instance ;private Logg...
Java-ThreadPoolExecutor使用
weixin_43169156的博客
05-12 303
Java-ThreadPoolExecutor使用 线程池主要由以下4个核心组件组成。 线程池管理器：用于创建并管理线程池 工作线程：线程池中执行具体任务的线程 任务接口：用于定义工作线程的调度和执行策略，只有线程实现了该接口，线程中的任务才能被线程池调度 任务队列：存放待处理的任务，新的任务将会不断被加入队列中，执行完成的任务将从队列中移除 ThreadPoolExecutor 如下是线程池的构造方法 public ThreadPoolExecutor(int corePoolSize,
JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)——读书笔记
模式
08-11 145
线程池类为 java.util.concurrent.ThreadPoolExecutor，常用构造方法为： ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, RejectedExecutionHand...
Java ThreadPoolExecutor 线程池的使用介绍
08-26
提供工厂方法来创建不同类型的线程池，这篇文章主要介绍了Java ThreadPoolExecutor 线程池的使用介绍，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来...
java ThreadPoolExecutor线程池
06-04
ThreadPoolExecutor是Java中用于创建线程池的一个类，它提供了丰富的线程池配置选项，可以用于满足不同场景下的多线程处理需求。 ThreadPoolExecutor主要包括以下四个参数： 1. corePoolSize：线程池中维护的线程...
ThreadPoolExecutor 线程池详解
瞎叨叨的一天的博客
07-09 529
ThreadPoolExecutor 线程池详解
java线程池ThreadPoolExecutor使用
qq_43456605的博客
05-22 2272
java线程池
java threadpool用法_Java ThreadPoolExecutor的使用
weixin_34244326的博客
03-04 180
/*** 内部消息出传送对象,单例对象.* 注意：如果是多线程在处理，那么对于那种有明确先后处理次序的消息不能使用。* */public class InnerMsgTransfer {private static InnerMsgTransfer instance ;private Logger log =LoggerFactory.getLogger(this.getClass()) ;/**...
java-ThreadPoolExecutor
test的博客
08-22 445
Java并发编程：线程池的使用 　　在前面的文章中，我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题： 　　如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。 　　那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？ 　　...
java ThreadPoolExecutor线程池的使用
weixin_39353771的博客
04-11 914
笔记: java ThreadPoolExecutor线程池的使用1 为什么使用线程池?2 创建线程池3 执行任务 1 为什么使用线程池? (1) 大量线程的创建和销毁会过度消耗系统资源 (2) 节省系统响应时间, 如果要处理请求, 而线程池中恰好有空闲的线程, 那么就可以直接处理, 无需创建新的线程; 不仅节省了系统资源, 无形中也缩减了响应请求的时间 (3) 控制程序创建线程的数量, 通过设置...
Java线程池ThreadPoolExecutor类使用详解
灵熙云工作室
07-29 353
在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，`不允许在应用中自行显示的创建线程`，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池`不允许使用Executors去创建，而要通过ThreadPoolExecutor方式`，这一方面是由于jdk中Executor框架虽然提供了如`newFixedThreadPool()`、`newSingleThreadExecutor()`、`newCachedThreadPoo
java 线程池ThreadPoolExecutor
u014230881的专栏
05-25 366
1. ThreadPoolExecutor的一个常用的构造方法 ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, RejectedExecutionHandler handler) 参数说明
Java线程池ThreadPoolExecutor详细介绍与使用
热门推荐
qq_27480007的博客
07-09 1万+
文章目录 前言 一、线程池基础 1、什么是线程池 2、为什么使用线程池 3、线程池有那些优势 二、线程池使用 1、Java内置线程池：ThreadPoolExecutor 2、通过Executor工厂类中的静态方法获取线程池对象 第一种、通过newCachedThreadPool获取线程池对象 第二种、通过newFixedThreadPool获取线程池对象 第三种、通过newSingleThreadExecutor获取线程池对象 关闭线程方法：shutdown和shutdownNow的区别 三种创建线程池的
Java使用ThreadPoolExecutor的建议
weixin_42002747的博客
08-26 176
使用有界队列，当任务过多时，线程池会触发执行拒绝策略，线程池默认的拒绝策略会throw RejectedExecutionException 这是个运行时异常，对于运行时异常编译器并不强制catch它，所以开发人员很容易略。因此默认拒绝策略要慎重使用。如果线程池处理的任务非常重要，建议自定义自己的拒绝策略；并且在实际工作中，自定义的拒绝策略往往和降级策略配合使用。 使用线程池，还要注意异常处理的问题，例如通过ThreadPoolExecutor对象的execute()方法提交任务时， 如果任务在执行的过程中
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值