概念
为了更好的控制多线程，JDK提供了一套线程框架Executor,帮助开发人员有效地进行线程控制。它们都java.util.concurrent包中，是JDK并发包的核心。其中有一个比较重要的类：Executors,他扮演着线程工厂的角色，我们通过Executors可以创建特定功能的线程池。
Executors创建线程池方法：
- newFixedThreadPool(int nThreads)，该方法会返回一个固定数量的线程池，该方法的线程数始终不变，当有一个任务提交时，若线程池中空闲，则立即执行，若没有，则会被暂缓在一个任务队列中等待有空闲的线程去执行
- newSingleThreadExecutor(),创建一个线程的线程池，若空闲则执行，若没有空闲线程则暂缓在任务队列中。
- newCachedThreadPool()，返回一个可根据实际情况调整线程个数的线程池，不限制最大线程数量，若有空闲的线程则执行任务，若无任务则不创建线程，并且每一个空闲线程会在60秒后自动回收。
- newScheduledThreadPool(int nThreads)，该方法返回一个SchededExecutorService对象，该线程池可以指定线程的数量。
源码
我们来分别看一下创建四个线程池方法的源码实现。我们会很惊奇的发现它们的相似之处
1.Executors.newFixedThreadPool(10)
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}2.Executors.newSingleThreadExecutor()
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}3.Executors.newCachedThreadPool()
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}4.Executors.newScheduledThreadPool(10)，在结构上可能有些不同，究其根本我们可以发现，它和前三种也是相似的。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}我们继续深入ScheduledThreadPoolExecutor(corePoolSize)
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}这里调用了父类的构函，我们来看它的父类是谁。
public class ScheduledThreadPoolExecutor
extends ThreadPoolExecutor
implements ScheduledExecutorService 会发现竟然也是ThreadPoolExecutor。
看了这四种创建线程池的源码，我们发现底层都是创建了一个ThreadPoolExecutor，每一种创建的方式，只是修改了参数。
我们来了解各个参数的含义。
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue)- corePoolSize，表示核心线程数，后面会做详细介绍
- maximumPoolSize，表示最大线程数
- keepAliveTime，表示线程空闲多长时间后被回收
- unit，表示时间的单位。keepAliveTime和unit必须配合起来使用
- workQueue，指定一个队列来存储线程处理不及的任务
事例
1.newScheduledThreadPool实例演示
public class Demo2 {
public static void main(String[] args) {
Temp command =new Temp();
ScheduledExecutorService service=Executors.newScheduledThreadPool(1);
ScheduledFuture<?> serviceTask=service.scheduleWithFixedDelay(command, 5, 1, TimeUnit.SECONDS);
}
}
class Temp extends Thread{
@Override
public void run() {
System.out.println("run...");
}
}运行结果：初始化5秒后，第一个run…在控制台打印出来，以后每隔一秒打印一个。
//关键是这条语句
/*
command，表示要执行的线程
5，表示初始化的时间
1，表示初始化后每次执行的时间间隔
TimeUnit.SECONDS，表示时间的单位是秒
*/
ScheduledFuture<?> serviceTask=service.scheduleWithFixedDelay(command, 5, 1, TimeUnit.SECONDS);自定义线程
若Executors工厂类无法满足我们的需求，可以自己去创建自定义的线程池，在上文我们可以看到JDK中提供的4中线程池内部实现都用了ThreadPoolExecutor这个类，这个类可以自定义线程。构造方法如下：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)我们再来介绍一下参数含义：
- corePoolSize，表示核心线程数，后面会做详细介绍
- maximumPoolSize，表示最大线程数
- keepAliveTime，表示线程空闲多长时间后被回收
- unit，表示时间的单位。keepAliveTime和unit必须配合起来使用
- workQueue，指定一个队列来存储线程处理不及的任务
- threadFactory，是指线程工厂
- handler，表示拒绝策略的机制，后面事例会详细演示
详细使用
这个构造方法对于队列是什么类型的比较关键。
- 若队列为有界队列：若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，若大于corePoolSize，则会将任务加入队列，若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新线程，若线程数大于maximumPoolSize，则执行拒绝策略，或其他自定义方式
- 若队列为无界队列：例如LinkedBlockingQueue，与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败。当有新任务到来，系统的线程数小于corePoolSize，则创建新线程执行任务。当到达corePoolSize后，就不会创建线程。若后续还有任务加入，而没有空闲的线程资源，则任务直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到内存资源耗尽。
JDK的拒绝策略：
- AbortPolicy:直接抛出异常，组织系统正常工作，但线程池中的线程不能被shutdown()
- CallerRunsPolicy:只要线程池未关闭，该策略直接在调用者线程中运行当前被丢弃的任务
- DiscardOldestPolicy:丢弃最老的一个请求，尝试再次提交当前任务。
- DiscardPolicy:丢弃无法处理的任务，不给予任何处理
- 如果需要自定义拒绝策略可以实现RejectedExecutionHandler接口
实例
首先定义一个任务类
public class MyTask implements Runnable {
private int taskId;
private String taskName;
public MyTask(int taskId, String taskName){
this.taskId = taskId;
this.taskName = taskName;
}
public int getTaskId() {
return taskId;
}
public void setTaskId(int taskId) {
this.taskId = taskId;
}
public String getTaskName() {
return taskName;
}
public void setTaskName(String taskName) {
this.taskName = taskName;
}
@Override
public void run() {
try {
System.out.println("run taskId =" + this.taskId);
Thread.sleep(5*1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public String toString(){
return Integer.toString(this.taskId);
}
}然后是主类，也就是执行类
public class UseThreadPoolExecutor {
/**
* 规则1.在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
* 规则2.若大于corePoolSize，则会将任务加入队列，
* 规则3.若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
* 规则4.若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
*
*/
//创建corePoolSize为1，maximumPoolSize为2的有界队列线程池
public static void main(String[] args) {
ThreadPoolExecutor pool=new ThreadPoolExecutor(
1,
2,
60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(3)
);
//创建一个任务
MyTask mt1=new MyTask(1, "MyTask1");
//执行任务
pool.execute(mt1);
//暂停线程
pool.shutdown();
}
}运行结果是：
打印run taskId =1后，5秒后线程结束。 符合规则1.
再看有四个任务
public class UseThreadPoolExecutor {
public static void main(String[] args) {
ThreadPoolExecutor pool=new ThreadPoolExecutor(
1,
2,
60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(3)
);
MyTask mt1=new MyTask(1, "MyTask1");
MyTask mt2=new MyTask(2, "MyTask2");
MyTask mt3=new MyTask(3, "MyTask3");
MyTask mt4=new MyTask(4, "MyTask4");
pool.execute(mt1);
pool.execute(mt2);
pool.execute(mt3);
pool.execute(mt4);
pool.shutdown();
}
}执行结果：打印run taskId =1后，5秒后打印run taskId =2 再过5秒打印run taskId =3，再过5秒打印run taskId =4，再过5秒线程结束，符合规则2. 任务2，任务3，任务4都先存放在有界队列中，此时线程池中只有一条线程，执行完任务1后，在按照队列先进先出的原则分别执行，任务2，任务3，任务4.
再看有5个任务的情况
public class UseThreadPoolExecutor {
public static void main(String[] args) {
ThreadPoolExecutor pool=new ThreadPoolExecutor(
1,
2,
60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(3)
);
MyTask mt1=new MyTask(1, "MyTask1");
MyTask mt2=new MyTask(2, "MyTask2");
MyTask mt3=new MyTask(3, "MyTask3");
MyTask mt4=new MyTask(4, "MyTask4");
MyTask mt5=new MyTask(5, "MyTask5");
pool.execute(mt1);
pool.execute(mt2);
pool.execute(mt3);
pool.execute(mt4);
pool.execute(mt5);
pool.shutdown();
}
}运行结果，任务1和任务5一起打印，5秒后任务2和任务3一起打印，再过5秒打印任务4，再过5秒线程结束。符合规则3.因为新加任务5的时候发现有界队列已经满了，并且线程池中只有一条线程小于maximumPoolSize的2.所以又创建了一条线程直接运行任务5.等到任务1和任务5运行完，这两条线程又分别运行任务2和任务3。最后运行任务4.
最后看一下6个任务的情况
public class UseThreadPoolExecutor {
public static void main(String[] args) {
ThreadPoolExecutor pool=new ThreadPoolExecutor(
1,
2,
60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(3)
);
MyTask mt1=new MyTask(1, "MyTask1");
MyTask mt2=new MyTask(2, "MyTask2");
MyTask mt3=new MyTask(3, "MyTask3");
MyTask mt4=new MyTask(4, "MyTask4");
MyTask mt5=new MyTask(5, "MyTask5");
MyTask mt6=new MyTask(6, "MyTask6");
pool.execute(mt1);
pool.execute(mt2);
pool.execute(mt3);
pool.execute(mt4);
pool.execute(mt5);
pool.execute(mt6);
pool.shutdown();
}
}结果，打印任务1,5并且任务6抛出异常在同一时间进行。过5秒后打印任务2,3，在过5秒打印任务4，最后线程一直在等待，没有结束。符合规则4.
我们可以看源码得知，没有指定拒绝策略的情况下，默认的拒绝策略就是AbortPolicy：直接抛出异常，组织系统正常工作。
private static final RejectedExecutionHandler defaultHandler =
new AbortPolicy();
我们还可以自定义拒绝策略
public class MyRejected implements RejectedExecutionHandler{
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("自定义处理.....");
System.out.println("当前被拒绝任务为："+r.toString());
}
}修改UseThreadPoolExecutor 类
public class UseThreadPoolExecutor {
public static void main(String[] args) {
ThreadPoolExecutor pool=new ThreadPoolExecutor(
1,
2,
60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(3)，
new
);
MyTask mt1=new MyTask(1, "MyTask1");
MyTask mt2=new MyTask(2, "MyTask2");
MyTask mt3=new MyTask(3, "MyTask3");
MyTask mt4=new MyTask(4, "MyTask4");
MyTask mt5=new MyTask(5, "MyTask5");
MyTask mt6=new MyTask(6, "MyTask6");
pool.execute(mt1);
pool.execute(mt2);
pool.execute(mt3);
pool.execute(mt4);
pool.execute(mt5);
pool.execute(mt6);
pool.shutdown();
}
}运行结果：自定义处理….. run taskId =5 run taskId =1 当前被拒绝任务为：6同时被打印，5秒后打印run taskId =2 run taskId =3 再过5秒打印run taskId =4 最后再过5秒线程结束。
最后我们补充一个知识点：
排队三种策略：
直接提交。如SynchronousQueue，它将任务直接提交给线程而不保持它们。也就是我只是其中间桥梁作用，一个任务过来，我只需要把这个任务直接交给线程，而不保存，适合任务量较少的场景。
无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize的值也就无效了。）
有界队列。如 ArrayBlockingQueue，直接指定了队列可存放的长度，对比无界队列可以有效的方式内存资源耗尽，在队列已满后继续添加任务，我们可以用记录日志的方式来下一次解决。
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
