ThreadPoolExecutor机制及各参数讲…

最新推荐文章于 2023-04-21 11:18:47 发布
最新推荐文章于 2023-04-21 11:18:47 发布
阅读量3.2k 收藏 2
点赞数
分类专栏： 线程
本文系转载，原文地址：http://825635381.iteye.com/blog/2184680

ThreadPoolExecutor机制 
一、概述  
1、ThreadPoolExecutor作为java.util.concurrent包对外提供基础实现，以内部线程池的形式对外提供管理任务执行，线程调度，线程池管理等等服务； 
2、Executors方法提供的线程服务，都是通过参数设置来实现不同的线程池机制。 
3、先来了解其线程池管理的机制，有助于正确使用，避免错误使用导致严重故障。同时可以根据自己的需求实现自己的线程池  

二、核心构造方法讲解  
下面是ThreadPoolExecutor最核心的构造方法  

publicThreadPoolExecutor(int corePoolSize,
                              intmaximumPoolSize,
                              longkeepAliveTime,
                              TimeUnitunit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw newIllegalArgumentException ();
        if (workQueue == null || threadFactory == null|| handler == null)
            throw newNullPointerException();
        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之间关系。 

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

线程管理机制图示： ThreadPoolExecutor机制及各参数讲解
三、Executors提供的线程池配置方案  

1、构造一个固定线程数目的线程池，配置的corePoolSize与maximumPoolSize大小相同，同时使用了一个无界LinkedBlockingQueue存放阻塞任务，因此多余的任务将存在再阻塞队列，不会由RejectedExecutionHandler处理  

publicstatic ExecutorService newFixedThreadPool(int nThreads){
        return new ThreadPoolExecutor(nThreads,nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
    }

2、构造一个缓冲功能的线程池，配置corePoolSize=0，maximumPoolSize=Integer.MAX_VALUE，keepAliveTime=60s,以及一个无容量的阻塞队列SynchronousQueue，因此任务提交之后，将会创建新的线程执行；线程空闲超过60s将会销毁  

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

3、构造一个只支持一个线程的线程池，配置corePoolSize=maximumPoolSize=1，无界阻塞队列LinkedBlockingQueue；保证任务由一个线程串行执行  

public static ExecutorService newSingleThreadExecutor(){
        return newFinalizableDelegatedExec utorService
            (newThreadPoolExecutor(1, 1,
                                    0L,TimeUnit.MILLISECONDS,
                                    newLinkedBlockingQueue()));
    }

4、构造有定时功能的线程池，配置corePoolSize，无界延迟阻塞队列DelayedWorkQueue；有意思的是：maximumPoolSize=Integer.MAX_VALUE，由于DelayedWorkQueue是无界队列，所以这个值是没有意义的  

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return newScheduledThreadPoolExecu tor(corePoolSize);
    }

public static ScheduledExecutorService newScheduledThreadPool(
            intcorePoolSize, ThreadFactory threadFactory) {
        return newScheduledThreadPoolExecu tor(corePoolSize, threadFactory);
    }

public ScheduledThreadPoolExecu tor(int corePoolSize,
                              ThreadFactory threadFactory) {
        super(corePoolSize, Integer.MAX_VALUE, 0,TimeUnit.NANOSECONDS,
              new DelayedWorkQueue(), threadFactory);
    }

四、定制属于自己的非阻塞线程池  

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.RejectedExecutionHandler ;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;


public class CustomThreadPoolExecutor {

private ThreadPoolExecutor pool = null;
public void init() {
pool = new ThreadPoolExecutor(
10,
30,
30,
TimeUnit.MINUTES,
new ArrayBlockingQueue(10),
new CustomThreadFactory(),
new CustomRejectedExecutionH andler());
}

public void destory() {
if(pool != null) {
pool.shutdownNow();
}
}
public ExecutorService getCustomThreadPoolExecu tor() {
return this.pool;
}
private class CustomThreadFactory implements ThreadFactory{

private AtomicInteger count = new AtomicInteger(0);
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
String threadName =CustomThreadPoolExecutor .class.getSimpleName() +count.addAndGet(1);
System.out.println(threadName);
t.setName(threadName);
return t;
}
}
private class CustomRejectedExecutionH andler implementsRejectedExecutionHandler {

@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutorexecutor) {
// 记录异常
// 报警处理等
System.out.println("error.............");
}
}
// 测试构造的线程池
public static void main(String[] args) {
CustomThreadPoolExecutor exec = newCustomThreadPoolExecutor ();
// 1.初始化
exec.init();
ExecutorService pool =exec.getCustomThreadPoolExecu tor();
for(int i=1; i<100; i++) {
System.out.println("提交第" + i + "个任务!");
pool.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("running=====");
}
});
}
// 2.销毁----此处不能销毁,因为任务没有提交执行完,如果销毁线程池,任务也就无法执行了
// exec.destory();
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}


方法中建立一个核心线程数为30个，缓冲队列有10个的线程池。每个线程任务，执行时会先睡眠3秒，保证提交10任务时，线程数目被占用完，再提交30任务时，阻塞队列被占用完，，这样提交第41个任务是，会交给CustomRejectedExecutionHandler异常处理类来处理。

提交任务的代码如下：

public void execute(Runnable command) {
        if (command == null)
            throw newNullPointerException();
       
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if(addWorker(command, true))
                return;
            c =ctl.get();
        }
        if (isRunning(c) &&workQueue.offer(command)) {
            intrecheck = ctl.get();
            if (!isRunning(recheck) && remove(command))
                reject(command);
            else if(workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

注意：41以后提交的任务就不能正常处理了，因为，execute中提交到任务队列是用的offer方法，如上面代码，这个方法是非阻塞的，所以就会交给CustomRejectedExecutionHandler来处理，所以对于大数据量的任务来说，这种线程池，如果不设置队列长度会OOM，设置队列长度，会有任务得不到处理，接下来我们构建一个阻塞的自定义线程池  

五、定制属于自己的阻塞线程池  

package com.tongbanjie.trade.test.commons;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.RejectedExecutionHandler ;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class CustomThreadPoolExecutor { 
 
       
    privateThreadPoolExecutor pool = null;  
       
       
     
    public void init() { 
        pool = new ThreadPoolExecutor( 
                1,  
                3,  
                30,  
                TimeUnit.MINUTES, 
                new ArrayBlockingQueue(5), 
                new CustomThreadFactory(), 
                newCustomRejectedExecutionH andler());  
    } 
   
       
    public void destory() { 
        if(pool != null) {  
            pool.shutdownNow();  
        }  
    } 
       
       
    public ExecutorServicegetCustomThreadPoolExecu tor() {  
        return this.pool;  
    } 
       
    private classCustomThreadFactory implements ThreadFactory { 
   
        private AtomicInteger count = newAtomicInteger(0);  
           
        @Override  
        public Thread newThread(Runnable r) { 
            Thread t =new Thread(r);  
            StringthreadName = CustomThreadPoolExecutor .class.getSimpleName() +count.addAndGet(1);  
            System.out.println(threadName);  
            t.setName(threadName);  
            return t; 
        }  
    } 
       
       
    private classCustomRejectedExecutionH andler implements RejectedExecutionHandler {  
   
        @Override  
        public void rejectedExecution(Runnable r,ThreadPoolExecutor executor) {  
        try {
                                // 核心改造点，由blockingqueue的offer改成put阻塞方法
executor.getQueue().put(r);
} catch (InterruptedException e) {
e.printStackTrace();
}
        }  
    } 
       
       
       
    // 测试构造的线程池 
    public static voidmain(String[] args) {  
   
        CustomThreadPoolExecutor exec = newCustomThreadPoolExecutor ();  
        // 1.初始化  
        exec.init();  
           
        ExecutorService pool =exec.getCustomThreadPoolExecu tor();  
        for(int i=1; i<100; i++) { 
            System.out.println("提交第" + i + "个任务!");  
            pool.execute(new Runnable() {  
                @Override 
                public void run() { 
                    try {  
                    System.out.println(">>>task isrunning====="); 
                        TimeUnit.SECONDS.sleep(10);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();  
                    }  
                }  
            }); 
        }  
           
           
        // 2.销毁----此处不能销毁,因为任务没有提交执行完,如果销毁线程池,任务也就无法执行了 
        // exec.destory();  
           
        try {  
            Thread.sleep(10000);  
        } catch (InterruptedException e) { 
            e.printStackTrace();  
        }  
    } 
}  

解释：当提交任务被拒绝时，进入拒绝机制，我们实现拒绝方法，把任务重新用阻塞提交方法put提交，实现阻塞提交任务功能，防止队列过大，OOM，提交被拒绝方法在下面  

public void execute(Runnable command) {
        if (command == null)
            throw newNullPointerException();

        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if(addWorker(command, true))
                return;
            c =ctl.get();
        }
        if (isRunning(c) &&workQueue.offer(command)) {
            intrecheck = ctl.get();
            if (!isRunning(recheck) && remove(command))
                reject(command);
            else if(workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            // 进入拒绝机制，我们把runnable任务拿出来，重新用阻塞操作put，来实现提交阻塞功能
            reject(command);
    }

总结：  
1、用ThreadPoolExecutor自定义线程池，看线程是的用途，如果任务量不大，可以用无界队列，如果任务量非常大，要用有界队列，防止OOM 
2、如果任务量很大，还要求每个任务都处理成功，要对提交的任务进行阻塞提交，重写拒绝机制，改为阻塞提交。保证不抛弃一个任务 
3、最大线程数一般设为2N+1最好，N是CPU核数 
4、核心线程数，看应用，如果是任务，一天跑一次，设置为0，合适，因为跑完就停掉了，如果是常用线程池，看任务量，是保留一个核心还是几个核心线程数 
5、如果要获取任务执行结果，用CompletionService，但是注意，获取任务的结果的要重新开一个线程获取，如果在主线程获取，就要等任务都提交后才获取，就会阻塞大量任务结果，队列过大OOM，所以最好异步开个线程获取结果

Allen-Han
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java线程池ThreadPoolExecutor详解（一篇就够了）
m0_67401270的博客
08-01 2703
Executor框架主要由三部分组成，任务，任务的执行者，执行结果，ThreadPoolExecutor和ScheduledThreadPoolExecutor的设计思想也是将这三个关键要素进行了解耦，将任务的提交和执行分离。任务在和中任务是指实现了Runnable接口和Callable接口的类，中将任务转换成FutureTask类，中任务被转换成类，该类继承FutureTask，并重写了run方法，实现了延时执行任务和周期性执行任务。任务的执行者包括任务执行机制的核心接口Executor的接口的和。...
ScheduledThreadPoolExecutor
最新发布
qq_33240556的博客
05-29 400
提供了强大的调度功能，可以方便地实现延迟任务和周期性任务。通过合理配置和管理，可以实现复杂的任务调度需求，提升应用程序的响应和性能。
idea 多线程debugger调试并发的方法
thankna的博客
11-25 3023
我是从eclipse迁移到idea，自己摸索多线程调试方法。 1.在断点上【右键】选Thread。 2.开两个线程发送请求（可以从画面上，分别使用两个用户发请求）。 下图中Threads标签下exec-10和exec-5就是两个线程。 如果看不到Threads标签，请参看下面设置。 debugger最右侧小方块按钮点击，下拉勾选Threads。 3.切换线程执行。 现在执行的是红色√的kjqjJs=8这个线程 点击下来列表选择●的线程。 切换成kjqjJs=7的线程。...
ThreadPoolExecutor 手动创建线程池
Q17532573105的博客
05-10 5338
ThreadPoolExecutor 手动创建线程池 ThreadPoolExecutor 手动创建线程池 ThreadPoolExecutor：最原始的创建线程池的方式 ThreadPoolExecutor 最多可以设置 7 个参数： 7 个参数代表的含义如下： corePoolSize：核心线程数，线程池中始终存活的线程数。 maximumPoolSize：最大线程数，线程池中允许的最大线程数，当线程池的任务队列满了之后可以创建的最大线程数。 keepAliveTime：最大线程数
线程池ThreadPoolExecutor的七大参数
热门推荐
诗水人间
11-13 4万+
七个参数的构造方法如下 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnabl
Java ThreadPoolExecutor的参数深入理解
08-31
Java ThreadPoolExecutor参数深入理解 Java ThreadPoolExecutor是Java并发编程中一个非常重要的组件，它提供了一种灵活的方式来管理线程池。ThreadPoolExecutor的参数深入理解是Java开发人员需要掌握的重要知识点，...
Java线程池ThreadPoolExecutor原理及使用实例
08-19
Java线程池ThreadPoolExecutor原理及使用实例 Java线程池ThreadPoolExecutor是Java并发编程中的一种基本机制，主要用于管理和执行任务的线程池。下面对其原理和使用实例进行详细介绍。 线程池概述 线程池是一个...
ThreadPoolExecutor运转机制介绍
12-19
介绍ThreadPoolExecutor中池和queue配合使用的机制
ThreadPoolExecutor线程池的使用方法
08-25
ThreadPoolExecutor线程池提供了灵活的线程管理机制，可以根据需要选择合适的任务队列和拒绝策略，并且可以自定义线程工厂和线程工具类，从而满足不同应用场景的需求。 ThreadPoolExecutor的使用方法可以分为以下几...
java ThreadPoolExecutor 并发调用实例详解
08-30
在这些机制中，ThreadPoolExecutor 是一个非常重要的概念，它提供了一个线程池，允许开发者将任务提交到线程池中，并行地执行这些任务。 ThreadPoolExecutor 的主要作用是管理一个线程池，线程池中包含多个线程，每...
线程阻塞队列
qq_39264897的博客
11-24 193
public class ConsumerProducerUsingBlockingQueue { //使用数组实现队列阻塞 private static ArrayBlockingQueue<Integer> buffer = new ArrayBlockingQueue<Integer>(2); public static void main(String[] args) { ExecutorService executor = Exe.
java多线程：ThreadPoolExecutor几个重要方法的详解
zhaoliubao1的博客
11-11 2888
1.shutdown()方法： Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.Invocation has no additional effect if already shut down.（启动有序关闭，在该关闭...
SpringBoot中使用ThreadPoolExecutor和ThreadPoolTaskExecutor线程池的方法和区别
smiling
10-29 4649
SpringBoot中使用ThreadPoolExecutor和ThreadPoolTaskExecutor的方式和区别
Java线程池、创建线程池核心参数以及每个参数的底层含义
m0_73311735的博客
04-21 272
线程池通过复用已经创建的线程对象缓解线程创建和销毁时的系统开销，从而提高系统运行效率。在Java中，通过ThreadPoolExecutor类实现线程池。ThreadPoolExecutor类提供了一个ExecutorService接口的默认实现，允许我们向线程池提交任务，并对任务进行管理。我们可以通过调整线程池中的参数来控制线程的创建和销毁行为。在这些参数的帮助下，我们可以根据应用程序的实际需求，创建出适合的线程池。但是，调整线程池参数的过程并不容易，因为需要考虑到很多因素，如处理器数量、内存大小等等。
Java线程池创建方式
qq_45278588的博客
02-23 269
java线程池
java线程池详解
人生就像一场戏
12-01 3万+
1.线程池使用场景？ java中经常需要用到多线程来处理一些业务，我们非常不建议单纯使用继承Thread或者实现Runnable接口的方式来创建线程，那样势必有创建及销毁线程耗费资源、线程上下文切换问题。同时创建过多的线程也可能引发资源耗尽的风险，这个时候引入线程池比较合理，方便线程任务的管理。java中涉及到线程池的相关类均在jdk1.5开始的java.util.concurrent包中，涉及到的几个核心类及接口包括：Executor、Executors、ExecutorService、ThreadPo
1 - 线程池的基础用法
xiaozhou的博客
12-08 322
线程池的基本用法
Java线程池ThreadPoolExecutor参数讲解、实例助记 保证你过目不忘
weixin_43275484的博客
08-22 729
Java线程池ThreadPoolExecutor参数讲解、实例助记 保证你过目不忘
ThreadPoolExecutor各参数含义
08-14
ThreadPoolExecutor的各参数含义如下： 1. corePoolSize: 核心线程池大小，即线程池中保持存活的线程数量。当线程池中的任务数量超过corePoolSize时，若有空闲线程则任务会直接交给空闲线程执行，若无空闲线程则...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值