转载

【每日一博】ThreadPoolExecutor 的参数理解

一、使用Executors创建线程池

之前创建线程的时候都是用的Executors的newFixedThreadPool(),newSingleThreadExecutor(),newCachedThreadPool()这三个方法。

1. newFixedThreadPool()

创建线程数固定大小的线程池。

2.newSingleThreadPool()

创建线程数为1的线程池，

3.newCachedThreadPool()

创建可缓冲的线程池。没有大小限制

二、使用ThreadPoolExecutor创建线程池

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;   }

1、corePoolSize核心线程数大小，当线程数<corePoolSize ，会创建线程执行runnable

2、maximumPoolSize 最大线程数，当线程数 >= corePoolSize的时候，会把runnable放入workQueue中

3、keepAliveTime 保持存活时间，当线程数大于corePoolSize的空闲线程能保持的最大时间。

4、unit 时间单位

5、workQueue 保存任务的阻塞队列

6、threadFactory 创建线程的工厂

7、handler 拒绝策略

任务执行顺序：

1、当线程数小于 corePoolSize时，创建线程执行任务。

2、当线程数大于等于corePoolSize并且workQueue没有满时，放入workQueue中

3、线程数大于等于 corePoolSize并且当workQueue满时，新任务新建线程运行，线程总数要小于maximumPoolSize

4、当线程总数等于maximumPoolSize并且workQueue满了的时候执行handler的rejectedExecution。也就是拒绝策略。

ThreadPoolExecutor默认有四个拒绝策略：

1、ThreadPoolExecutor.AbortPolicy() 直接抛出异常RejectedExecutionException

2、ThreadPoolExecutor.CallerRunsPolicy() 直接调用run方法并且阻塞执行

3、 ThreadPoolExecutor. DiscardPolicy() 直接丢弃后来的任务

4、ThreadPoolExecutor. DiscardOldestPolicy() 丢弃在队列中队首的任务

当然可以自己继承RejectedExecutionHandler来写拒绝策略.

int corePoolSize = 1;   int maximumPoolSize = 2;   int keepAliveTime = 10; //  BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();   BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(5);   ThreadFactory threadFactory = Executors.defaultThreadFactory();   //线程池和队列满了之后的处理方式   //1.跑出异常   RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();    RejectedExecutionHandler handler2 = new ThreadPoolExecutor.CallerRunsPolicy();   RejectedExecutionHandler handler3 = new ThreadPoolExecutor.DiscardPolicy();   RejectedExecutionHandler handler4 = new ThreadPoolExecutor.DiscardOldestPolicy();       ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.SECONDS, workQueue, threadFactory, handler2);         for (int j = 1; j < 15; j++) {    threadPoolExecutor.execute(new Runnable() {          public void run() {            try {       System.out.println(Thread.currentThread().getName());       TimeUnit.SECONDS.sleep(1);      } catch (InterruptedException e) {       e.printStackTrace();      }                 }    });   }      System.out.println(threadPoolExecutor);     }

正文到此结束