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<Runnable>());  //无界队列  如果这个任务没有空闲线程就会 缓存到这个线程中}

newSingleThreadExecutor()方法，创建一个线程的程池，若空闲则执行，若没有空闲线程则暂缓在任务列队中。

具体源码如下：

public static ExecutorService newSingleThreadExecutor() {        return new FinalizableDelegatedExecutorService            (new ThreadPoolExecutor(1, 1,                                      0L, TimeUnit.MILLISECONDS,                                    new LinkedBlockingQueue<Runnable>()));    }

newCachedThreadPool()方法，返回一个可以根据实际情况调整线程个数的线程池，不限制最大线程数量，若用空闲的线程则执行任务，若无任务则不创建线程。并且每一个空闲线程会在60秒后自动回收。

具体源码如下：

public static ExecutorService newCachedThreadPool() {        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,                                      60L, TimeUnit.SECONDS,  //如果有一个线程 来60s了 还是没有另一个线程进来 则这个现场将会被回收 ，60s之内有线程进来，则不被回收                                      new SynchronousQueue<Runnable>()); //来一个任务就直接提交给 SynchronousQueue<Runnable>()    }

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<Runna ble> 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<Runnable> queue =                 //new LinkedBlockingQueue<Runnable>();  //这个是无界的                new ArrayBlockingQueue<Runnable>(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任务5queue 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<Runnable>(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 =1Exception 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 =2run taskId =3run 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<Runnable>(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 =1run taskId =5当前被拒绝任务为：6run taskId =2run taskId =3run taskId =4

源代码：https://github.com/hfbin/Thread_Socket/tree/master/Thread/concurrent018