ThreadPoolExecutor执行原理

原創

GhostRiderQin

2020-05-12 06:20

线程池

基本概念： 一种线程使用模式。线程过多会带来调度开销,进而影响缓存局部性和整体性能。

不要使用Executor创建线程池，而是通过ThreadPoolExecutor的方式创建，这样的处理方式能让编写代码的人更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors 返回的线程池对象的弊端如下：

1）FixedThreadPool和SingleThreadPool：

允许请求的队列长度为Interger.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。

2）CachedThreadPool：

允许的创建线程数量为：Interger.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

Executor创建线程的3大方法：

//Executor不建议使用，容易引发OOM
ExecutorService threadPool = Executors.newSingleThreadExecutor();//单线程
ExecutorService threadPool1 = Executors.newFixedThreadPool(5);//固定线程
ExecutorService threadPool2 = Executors.newCachedThreadPool();//可变线程

for (int i = 0; i < 10; i++) {
    threadPool2.execute(()->{
        System.out.println(Thread.currentThread().getName());
    });
}

ThreadPoolExecutor的七大参数：

核心线程数，最大线程数，超时等待时间，超时等待单位，阻塞队列，线程工厂，拒绝策略。

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

执行过程：如果线程数没有超过核心线程数，那么就会用到几个开辟几个，如果大于核心线程数，但是没有超过阻塞队列的个数，那么就会等待核心线程执行完，再取阻塞队列中的执行

测试代码：

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
    2,
    6,
    3,
    TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(3),
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.AbortPolicy()
);
try {
    for (int i = 0; i < 7; i++) {
        final int temp = i;
        threadPoolExecutor.execute(()->
                                   {
                                       try {
                                           System.out.println(Thread.currentThread().getName()+" "+temp);
                                           TimeUnit.SECONDS.sleep(1);
                                       } catch (InterruptedException e) {
                                           e.printStackTrace();
                                       }

                                   });
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    threadPoolExecutor.shutdown();
}