Java线程池的总结

Java线程池总结

线程池的好处

1. 降低资源消耗
2. 提高响应速度
3. 提高线程的可管理性

线程池相关的具体参数

1. corePoolSize
   • 线程池的核心线程数。在没有设置 allowCoreThreadTimeOut 为 true 的情况下，核心线程会在线程池中一直存活，即使处于闲置状态。
2. maximumPoolSize
   • 线程池所能容纳的最大线程数。当活动线程到达这个数值后，后续任务将会根据RejectedExecutionHandler 来进行拒绝策略处理。
3. keepAliveTime
   • 非核心线程闲置的超时时长。超过该时长，非核心线程就会被回收。
   • 若线程池通过allowCoreThreadTimeOut()方法设置allowCoreThreadTimeOut属性为True，则该时长同样会作用于核心线程，AsyncTask配置的线程池就是这样设置的。
4. unit
   • keepAliveTime时长对应的单位。
5. workQueue
   • 线程池中的任务队列，通过线程池的execute()方法提交的Runnable对象会存储在该队列中。
6. ThreadFactory
   • 线程工厂，为线程池提供创建新线程的功能。通过自定义，做一些自定义线程名的操作。
7. RejectedExecutionHandler
   • 当任务无法执行时(超过线程最大容量maximum并且workQueue已经被排满了)的处理策略。
   • 四种拒绝类型
     • ThreadPoolExecutor.AbortPolicy : 当线程池中的数量等于最大线程数时抛 java.util.concurrent.RejectedExecutionException 异常，涉及到该异常的任务也不会被执行，线程池默认的拒绝策略就是该策略。
     • ThreadPoolExecutor.DiscardPolicy() : 当线程池中的数量等于最大线程数时,默默丢弃不能执行的新加任务，不报任何异常
     • ThreadPoolExecutor.CallerRunsPolicy() : 当线程池中的数量等于最大线程数时，重试添加当前的任务；它会自动重复调用execute()方法。
     • ThreadPoolExecutor.DiscardOldestPolicy() : 当线程池中的数量等于最大线程数时,抛弃线程池中工作队列头部的任务(即等待时间最久的任务)，并执行新传入的任务。

线程池执行任务的顺序

1. 当线程数小于核心线程数时，创建线程，并处理请求
2. 当线程数大于等于核心线程数时，且任务队列未满时，将任务放入任务队列，随着线程池中核心线程们不断执行任务，只要线程池中有空闲的核心线程，线程池就从任务队列中取任务并处理
3. 当线程数大于等于核心线程数时，且任务队列已满时
   1. 若线程数小于最大线程数，创建线程
   2. 若线程数等于最大线程数，抛出异常，拒绝任务

newCachedThreadPool

1. 具有缓存性质的线程池，线程可重复利用
2. 线程最大空闲时间60s
3. 没有最大线程数限制
4. 适用于任务耗时短，数量大
5. 等待队列是没有容量的

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CachedThreadPoolTest {
   public static void main(String[] args) {
       ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
       for (int i = 0; i < 10; i++) {
           final int index = i;
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }

           Runnable task = new Runnable() {
               public void run() {
                   System.out.println(Thread.currentThread().getName() + ">>" + index);
               }
           };

           cachedThreadPool.execute(task);
       }
   }
}

newFixedThreadPool

1. 具有固定数量的线程池
2. 核心线程数等于最大线程数
3. 线程最大空闲时间0
4. 执行完即销毁
5. 超出最大线程数进行等待
6. 高并发下控制性能

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolTest {
    public static void main(String[] args) {
        System.out.println(Runtime.getRuntime().availableProcessors());
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(8);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName() + ">>" + index);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

newScheduledThreadPool

1. 具有时间调度特性
2. 必须初始化核心线程数
3. 底层使用DelayWorkQueue实现延迟特性

newSingleThreadPool

1. 核心线程数与最大线程数为1
2. 用于不需要并发顺序执行

参考链接

http://gudong.name/2017/05/03/thread-pool-intro.html