java线程安全之Executor框架及自定义线程池（十五）
Executor框架及自定义线程池
Executor框架
概念理解
为了更好的控制多线程，JDK提供了一套线程框架Executor,帮助开发人员有效地进行线程控制。它们都在Java.util.concurrent包中，是JDK并发包的核心。其中有一个比较重要的类：Executors,他扮演这线程工厂的角色，我们通过Executors可以创建特定功能的线程池。Executors创建线程池方法：
newFixedThreadPool()方法，该方法返回一个固定数量的线程池，该方法的线程数始终不变，当有一个任务提交时，若线程池中空闲，则立即执行，若没有，则会被暫缓在一个任务队列中等待有空闲的线程去执行·
具体源码如下：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads, //初始化多少个线程 / 最大线程
0L, TimeUnit.MILLISECONDS, //这两个参数一起用的等待的时间 这里为 0
new LinkedBlockingQueue()); //无界队列 如果这个任务没有空闲线程就会 缓存到这个线程中
} newSingleThreadExecutor()方法，创建一个线程的程池，若空闲则执行，若没有空闲线程则暂缓在任务列队中。
具体源码如下：
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue()));
} newCachedThreadPool()方法，返回一个可以根据实际情况调整线程个数的线程池，不限制最大线程数量，若用空闲的线程则执行任务，若无任务则不创建线程。并且每一个空闲线程会在60秒后自动回收。
具体源码如下：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS, //如果有一个线程 来60s了 还是没有另一个线程进来 则这个现场将会被回收 ，60s之内有线程进来，则不被回收
new SynchronousQueue()); //来一个任务就直接提交给 SynchronousQueue()
} newScheduledThreadPool()方法，该方法返回一个SchededExecutorSrevice对象，但该线程池可以指定线程的数量。
具体源码如下：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}
自定义线程池
若Executors工厂类无法满足我们的需求，可以自己去创建自定义的线程池，其实 ecuto工厂类里面的创建线程方法其内部实现均是用了ThreadPoolExecutor这个类，这个类可以自定义线程。构造方法如下：
public ThreadPooIExecutor(
int corePoolSize，
int maximumPoolSize，
long keepAIiveTime ,
TimeUnit unit，
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {……} 参数说明：
corePoolSize：核心线程池的大小，在线程池被创建之后，其实里面是没有线程的。（当然，调用prestartAllCoreThreads()或者prestartCoreThread()方法会预创建线程，而不用等着任务的到来）。当有任务进来的时候，才会创建线程。当线程池中的线程数量达到corePoolSize之后，就把任务放到 缓存队列当中。（就是 workQueue）。
maximumPoolSize：最大线程数量是多少。它标志着这个线程池的最大线程数量。如果没有最大数量，当创建的线程数量达到了 某个极限值，到最后内存肯定就爆掉了。
keepAliveTime：当线程没有任务时，最多保持的时间，超过这个时间就被终止了。默认情况下，只有 线程池中线程数量 大于 corePoolSize时，keepAliveTime值才会起作用。也就说说，只有在线程池线程数量超出corePoolSize了。我们才会把超时的空闲线程给停止掉。否则就保持线程池中有 corePoolSize 个线程就可以了。
workQueue：用来存储待执行任务的队列，不同的线程池它的队列实现方式不同（因为这关系到排队策略的问题）比如有以下几种
ArrayBlockingQueue：基于数组的队列，创建时需要指定大小。 LinkedBlockingQueue：基于链表的队列，如果没有指定大小，则默认值是 Integer.MAX_VALUE。（newFixedThreadPool和newSingleThreadExecutor使用的就是这种队列）。 SynchronousQueue：这种队列比较特殊，因为不排队就直接创建新线程把任务提交了。（newCachedThreadPool使用的就是这种队列）。
Unit：参数keepAliveTime的时间单位。
threadFactory:线程工厂，用来创建线程。
Handler：拒绝执行任务时的策略，一般来讲有以下四种策略，
（1） ThreadPoolExecutor.AbortPolicy 丢弃任务，并抛出 RejectedExecutionException 异常。
（2） ThreadPoolExecutor.CallerRunsPolicy：该任务被线程池拒绝，由调用 execute方法的线程执行该任务。
（3） ThreadPoolExecutor.DiscardOldestPolicy ： 抛弃队列最前面的任务，然后重新尝试执行任务。
（4） ThreadPoolExecutor.DiscardPolicy，丢弃任务，不过也不抛出异常。
自定义线程池使用详细
这个构造方法对于队列是什么类型的比较关键：
在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePooISize,则优先创建线程，若大于corePooISize，则会将任务入队列，若队列已满，则在总线程数不大于
MaximunPoolSize的前提下，创建新的线程，若线程数大于MaximunPoolSize，则执行拒绝策略，或其他自定义方式。
无界的任务队列时，LinkedBIockinaQueue。与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败的情况。当有新任务到来，系统的线程数小于corePooISize时，则新建线程执行任务。当达到corePooISize后，就不会继续增加。若后续仍有新的任务加入，而没有空闲的线程资源，则任务接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统内存。
JDK拒绝策略：
AbortPolicy:直接出异常组织系统正常工作
CallerRunPolicy：只要线程池未关团，该策略直接在调用者线程中，运行当前被丢弃的任务
DiscardOldestPolicy：丢弃最老的一个请隶，尝试再次提交当前任务
DiscardPolicy:丢弃无法处理的任务，不给予任何处理，如果需要自定义拒绝簽略可以实现RejectdExceutionHandler接口。
有界队列案例1：
public class UseThreadPoolExecutor2 implements Runnable{
private static AtomicInteger count = new AtomicInteger(0);
@Override
public void run() {
try {
int temp = count.incrementAndGet();
System.out.println("任务" + temp);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception{
//System.out.println(Runtime.getRuntime().availableProcessors());
BlockingQueue queue =
//new LinkedBlockingQueue(); //这个是无界的
new ArrayBlockingQueue(10);
ExecutorService executor = new ThreadPoolExecutor(
5, //core
10, //max
120L, //2fenzhong
TimeUnit.SECONDS,
queue);
for(int i = 0 ; i < 20; i++){
executor.execute(new UseThreadPoolExecutor2());
}
Thread.sleep(1000);
System.out.println("queue size:" + queue.size()); //10
Thread.sleep(2000);
}
}
打印结果：
任务2
任务1
任务3
任务4
任务5
queue size:5
任务6
任务10
任务9
任务8
任务7有界队列案例2：
MyTask.java
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(3*1000);
//System.out.println("end taskId =" + this.taskId);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public String toString(){
return Integer.toString(this.taskId);
}
}UseThreadPoolExecutor1.java
public class UseThreadPoolExecutor1 {
public static void main(String[] args) {
/**
* 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
* 若大于corePoolSize，则会将任务加入队列，
* 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
* 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
*
*/
ThreadPoolExecutor pool = new ThreadPoolExecutor(
1, //coreSize
2, //MaxSize
60, //60
TimeUnit.SECONDS,
new ArrayBlockingQueue(3) //指定一种队列 （有界队列 先进先出）
);
MyTask mt1 = new MyTask(1, "任务1");
MyTask mt2 = new MyTask(2, "任务2");
MyTask mt3 = new MyTask(3, "任务3");
MyTask mt4 = new MyTask(4, "任务4");
MyTask mt5 = new MyTask(5, "任务5");
MyTask mt6 = new MyTask(6, "任务6");
pool.execute(mt1);
pool.execute(mt2);
pool.execute(mt3);
pool.execute(mt4);
pool.execute(mt5);
pool.execute(mt6);
//关闭
pool.shutdown();
}
}
打印结果：
run taskId =1
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task 6 rejected from java.util.concurrent.ThreadPoolExecutor@6d6f6e28[Running, pool size = 2, active threads = 2, queued tasks = 3, completed tasks = 0]
run taskId =5
at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
at com.bjsxt.height.concurrent018.UseThreadPoolExecutor1.main(UseThreadPoolExecutor1.java:48)
run taskId =2
run taskId =3
run taskId =4从打印结果可以看出线程6并没有执行，是因为配置连接池最大链接数为2，所以才报错了，如果你把2改成3这时候就不会出现错了。
既然出现错了那就说一下JDK拒绝策略（详细说明在前面有，在这说一下自定义的拒绝方式）：
上面这个错属于jdk中的AbortPolicy这种策略，抛出异常系统还会继续工作（出错时jdk默认的拒绝策略）。
下面说一下自定义的拒绝方式需要，实现RejectdExceutionHandler接口
MyRejected.java
public class MyRejected implements RejectedExecutionHandler{
public MyRejected(){
}
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("自定义处理..");
System.out.println("当前被拒绝任务为：" + r.toString());
}
}
UseThreadPoolExecutor1.java
public class UseThreadPoolExecutor1 {
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(
1, //coreSize
2, //MaxSize
60, //60
TimeUnit.SECONDS,
new ArrayBlockingQueue(3) //指定一种队列 （有界队列 先进先出）
, new MyRejected() //自定义拒绝方式
//, new DiscardOldestPolicy() //丢弃最老的一个任务，执行新的任务
);
MyTask mt1 = new MyTask(1, "任务1");
MyTask mt2 = new MyTask(2, "任务2");
MyTask mt3 = new MyTask(3, "任务3");
MyTask mt4 = new MyTask(4, "任务4");
MyTask mt5 = new MyTask(5, "任务5");
MyTask mt6 = new MyTask(6, "任务6");
pool.execute(mt1);
pool.execute(mt2);
pool.execute(mt3);
pool.execute(mt4);
pool.execute(mt5);
pool.execute(mt6);
pool.shutdown();
}
}
打印结果：
自定义处理..
run taskId =1
run taskId =5
当前被拒绝任务为：6
run taskId =2
run taskId =3
run taskId =4
源代码：https://github.com/hfbin/Thread_Socket/tree/master/Thread/concurrent018