实现线程池,有四种策略:
生成线程池采用了工具类Executors的静态方法,以下是四种常见的线程池。
SingleThreadExecutor:单个后台线程 (其缓冲队列是无界的)。
创建一个单线程的线程池。这个线程池只有一个核心线程在工作,也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束,那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
( new ThreadPoolExecutor(1, 1,
0L, TimeUnit. MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
FixedThreadPool:只有核心线程的线程池,大小固定 (其缓冲队列是无界的) 。
创建固定大小的线程池。每次提交一个任务就创建一个线程,直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程。
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit. MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
CachedThreadPool:无界线程池,可以进行自动线程回收。
如果线程池的大小超过了处理任务所需要的线程,那么就会回收部分空闲(60秒不执行任务)的线程,当任务数增加时,此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小。SynchronousQueue是一个是缓冲区为1的阻塞队列。
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit. SECONDS,
new SynchronousQueue<Runnable>());
}
ScheduledThreadPool:核心线程池固定,大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
创建一个周期性执行任务的线程池。如果闲置,非核心线程池会在DEFAULT_KEEPALIVEMILLIS时间内回收。
public static ScheduledExecutorService newScheduledThreadPool (int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor( int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
new DelayedWorkQueue());
}
提交任务方式
ExecutorService.execute(Runnable runable);
FutureTask task = ExecutorService.submit(Runnable runnable);
FutureTask<T> task = ExecutorService.submit(Runnable runnable,T Result);
FutureTask<T> task = ExecutorService.submit(Callable<T> callable);
package com.xyz.demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
public class ExecutorsDemo {
private final static Logger logger=LoggerFactory.getLogger(ExecutorsDemo.class);
private static ThreadFactory nameThreadFactory=new ThreadFactoryBuilder()
.setNameFormat("demo-pool-%d").build();
/**
* corePoolSize - 池中所保存的线程数,包括空闲线程。
* maximumPoolSize-池中允许的最大线程数。
* keepAliveTime - 当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间。
* unit - keepAliveTime 参数的时间单位。
* workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute方法提交的 Runnable任务。
* threadFactory - 执行程序创建新线程时使用的工厂。
* handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。
*/
private static ExecutorService pool=new ThreadPoolExecutor(5, 10, 0L,
TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(1024), nameThreadFactory,
new ThreadPoolExecutor.AbortPolicy());
public static void main(String[] args) {
for(int i=0;i<Integer.MAX_VALUE;i++) {
pool.execute(new Thread() {
@Override
public void run() {
logger.info(Thread.currentThread().getName());
}
});
}
}
}
Executors 返回线程池对象的弊端如下:
FixedThreadPool 和 SingleThreadExecutor : 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求,从而导致OOM。
CachedThreadPool 和 ScheduledThreadPool : 允许创建的线程数量为 Integer.MAX_VALUE ,可能会创建大量线程,从而导致OOM。