newCachedThreadPool
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),
threadFactory);
}
- 核心线程数corePoolSize=0;
- 最大线程数maxinumPoolSize=Integer.MAX_VALUE;
- 空闲线程存活时间keepAliveTime=60;
- 存放线程任务队列workQueue=new SynchronousQueue()
由于任务队列采用SynchronousQueue:
一个不缓存任务的阻塞队列,生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时,不会缓存,而是直接被调度执行该任务,如果没有可用线程,则创建新线程,如果线程数量达到maxPoolSize,则执行拒绝策略。
也就是说,只要有任务到达,立即从线程池中获取空闲线程,如果没有空闲,则立即创建新的线程。
由于,核心线程数corePoolSize=0;
由于maxinumPoolSize=Integer.MAX_VALUE,意味着他的线程数几乎可以无限增加。
而keepAliveTime是指非核心线程的空闲时间超出该参数,该线程就会被终止。
因此,该线程池所有线程都是非核心线程,因此keepAliveTime=60对所有线程都有效。
因此,在有执行时间很短的大量任务需要执行时,newCachedThreadPool能够很好地复用运行中的线程(空闲并且还存活)资源来提高系统的运行效率。
newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
- 核心线程数corePoolSize=nThreads;
- 最大线程数maxinumPoolSize=nThreads;
- 空闲线程存活时间keepAliveTime=0;
- 存放线程任务队列workQueue=new LinkedBlockingQueue()
corePoolSize=maxinumPoolSize=nThreads(固定长度),不存在非核心线程的扩充,当没有空闲线程时,任务在队列中等待,当队列满时,触发拒绝机制。(如果maxinumPoolSize>corePoolSize,当队列满时,会新建线程:非核心线程)
LinkedBlockingQueue是基于链表的无界阻塞队列(其实最大容量为Interger.MAX),按照FIFO排序。由于该队列的近似无界性,当线程池中线程数量达到corePoolSize后,再有新任务进来,会一直存入该队列,而不会去创建新线程直到maxPoolSize,因此使用该工作队列时,参数maxPoolSize其实是不起作用的。
非核心线程:个数=maxinumPoolSize-corePoolSize,只有当任务队列满时,才会触发创建非核心线程。
而之前讲过:keepAliveTime参数只针对非核心线程有效,而核心线程属于常驻线程,没有存活时间限制。
因为该线程池corePoolSize=maxinumPoolSize,非核心线程数为0,因此空闲线程存活时间keepAliveTime以及其单位都是没有意义的。
newScheduledThreadPool
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public static ScheduledExecutorService newScheduledThreadPool(
int corePoolSize, ThreadFactory threadFactory) {
return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}
public ScheduledThreadPoolExecutor(int corePoolSize,
ThreadFactory threadFactory) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue(), threadFactory);
}
newSingleThreadExecutor
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory));
}
- 核心线程数corePoolSize=1;
- 最大线程数maxinumPoolSize=1;
- 空闲线程存活时间keepAliveTime=0;
- 存放线程任务队列workQueue=new LinkedBlockingQueue()
该线程池和newFixedThreadPool线程池类似,只是将核心线程数设为1.
由于LinkedBlockingQueue容量近似无限大的特征,当有新的任务到来时,首先判断唯一的线程是否空闲,如果空闲,则处理任务,否则加入队列等待。
该线程池可以保证所有任务按指定顺序(FIFO, LIFO, 优先级)执行。
注:当唯一的线程停止或发生异常时,该线程池会重新创建一个新的进程。
newWorkStealingPool (1.8引入)
public static ExecutorService newWorkStealingPool(int parallelism) {
return new ForkJoinPool
(parallelism,
ForkJoinPool.defaultForkJoinWorkerThreadFactory,
null, true);
}
public static ExecutorService newWorkStealingPool() {
return new ForkJoinPool
(Runtime.getRuntime().availableProcessors(),
ForkJoinPool.defaultForkJoinWorkerThreadFactory,
null, true);
}
public ForkJoinPool(int parallelism,
ForkJoinWorkerThreadFactory factory,
UncaughtExceptionHandler handler,
boolean asyncMode) {
this(checkParallelism(parallelism),
checkFactory(factory),
handler,
asyncMode ? FIFO_QUEUE : LIFO_QUEUE,
"ForkJoinPool-" + nextPoolId() + "-worker-");
checkPermission();
}