线程池ThreadPoolExecutor笔记

线程的创建方法

1、继承Thread类,没有返回值;
2、实现Runnable接口,没有返回值;
3、实现Callable接口通过FutureTask包装器来创建Thread线程,可以有返回值;
4、通过线程池实现,两种方法都提供。

线程池

一、通过Executors类提供的方法

  • 底层还是通过ThreadPoolExecutor构造方法实现,只是通过设置默认参数来实现。
1、newCachedThreadPool
  • 创建一个可缓存的线程池,若线程数超过处理所需,缓存一段时间后会回收,若线程数不够,则新建线程。
public static ExecutorService newCachedThreadPool() {
     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                       60L, TimeUnit.SECONDS,
                                       new SynchronousQueue<Runnable>());
}

因为SynchronousQueue队列不保持它们,直接提交给线程,相当于队列大小为0,而最大线程数为Integer.MAX_VALUE,所以线程不足时,会一直创建新线程,等到线程空闲时,又有60秒存活时间,从而实现了一个可缓存的线程池。

2、newFixedThreadPool
  • 创建一个固定大小的线程池,可控制并发的线程数,超出的线程会在队列中等待。
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>());
}

因为核心线程数与最大线程数相同,所以线程池的线程数是固定的,而且没有限制队列的大小,所以多余的任务均会被放到队列排队,从而实现一个固定大小,可控制并发数量的线程池。

3、newScheduledThreadPool
  • 创建一个周期性的线程池,支持定时及周期性执行任务。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,new DelayedWorkQueue());
}

因为使用了延迟队列,只有在延迟期满时才能从中提取到元素,从而实现定时执行的线程池。而周期性执行是配合上层封装的其他类来实现的,可以看ScheduledExecutorService类的scheduleAtFixedRate方法。

注意:这里用的是ScheduledExecutorService类的schedule()方法,不是ExecutorService类的execute()方法。

4、newSingleThreadExecutor
  • 创建一个单线程的线程池,可保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>()));
}

因为核心线程数与最大线程数相同,均为1,所以线程池的线程数是固定的1个,而且没有限制队列的大小,所以多余的任务均会被放到队列排队,从而实现一个单线程按指定顺序执行的线程池。

二、通过ThreadPoolExecutor类自定义

  • ThreadPoolExecutor类提供了4种构造方法,可根据需要来自定义一个线程池。
/**
 * @param corePoolSize    核心线程数,始终存活
 * @param maximumPoolSize 线程池中允许的最大线程数
 * @param keepAliveTime   存活时间,没有任务运行时存活的时间
 * @param unit            keepAliveTime的单位,
 * 						  TimeUnit枚举类,天、小时、分、秒、毫秒、微秒、纳秒
 * @param workQueue       一个阻塞队列,用来存储等待执行的任务,均为线程安全,7种可选。
 *                        较常用的是LinkedBlockingQueue和Synchronous。
 * 						  线程池的排队策略与BlockingQueue有关。 * 						  
 * @param threadFactory   线程工厂,主要用来创建线程,默及正常优先级、非守护线程。
 * @param handler         拒绝策略,拒绝处理任务时的策略,4种可选,默认为AbortPolicy。
 * @description ThreadPoolExecutor 线程池构造方法
 */
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                          BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    // 省略...
}

【强制】线程池不允许使用Executors去创建,而是通过ThreadPoolExecutor的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。

Executors返回的线程池对象的弊端如下:
FixedThreadPool和SingleThreadPool:允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求,从而导致OOM。
CachedThreadPool和ScheduledThreadPool:允许的创建线程数量为Integer.MAX_VALUE,可能会创建大量的线程,从而导致OOM。

在线程池中,当核心线程数不够时,工作任务会存入线程队列中;
当线程队列存满时,才会去判断最大线程数是否已满,再创建新的线程;
如果队列存满,当前工作线程数等于最大线程数,则会根据选择的拒绝策略执行。

你可能感兴趣的:(并发编程)