003 线程池核心-ThradPoolExecutor自定义线程池

•自定义线程池：若Executors工厂无法满足我们的需求，可以自己创建自定义线程池，其实Executors工厂类里面的创建线程方法其内部实现均是用了ThreadPoolExecutor这个类，这个类可以自定义线程。构造方法如下：

•队列类型参数选择：

•在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，若大于corePoolSize，则会将任务加入队列，若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。

•在使用无界队列时：LinkedBlockingQueue。与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败的情况。当有新任务到来，系统的线程数小于corePoolSize时，则新建线程执行任务。当达到corePoolSize后，就不会继续增加。若后续仍有新的任务加入，而有没有空闲的线程资源，则任务直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统内存。 【所有在实际生产中不推荐使用无界队列】

public class UseThreadPoolExecutor {

    public static void main(String[] args) {
        //创建自定义线程池（采用参数最多的构造器）
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,//corePoolSize, 核心线程数，线程池初始化的时候就会被创建
                3,//maximumPoolSize, 线程池的最大上限  //在使用无界队列的时候此参数无效
                60,//keepAliveTime, 线程空闲时间，即线程存活时间
                TimeUnit.SECONDS,//unit, 时间戳,空闲时间单位为秒
                //workQueue, 需要传入队列，此处需要提供一个BlockingQueue接口下面的实现类，可以使用有界队列和无界队列
                new ArrayBlockingQueue<>(2),//使用有界队列：ArrayBlockingQueue
                //new LinkedBlockingQueue<>(),  //使用无界队列：LinkedBlockingQueue
                new ThreadFactory() {
                    //线程工厂就是为了满足对线程操作的个性化需求
                    @Override
                    public Thread newThread(Runnable r) {
                        //创建一个线程，定义名称为"order-thread"
                        Thread th = new Thread(r,"order-thread");
                        //判断如果线程优先级被修改，那么改变优先级状态
                        if(th.getPriority() != Thread.NORM_PRIORITY) {
                            th.setPriority(Thread.NORM_PRIORITY);
                        }
                        //如果是守护线程，即后台一直运行的线程，将其改变为正常线程，使用后释放
                        if(th.isDaemon()) {
                            th.setDaemon(false);
                        }
                        //... 以上就是个性化线程操作，还有很多
                        return th;
                    }
                    
                },
                //使用无界队列是，拒绝策略无效
                new RejectedExecutionHandler() {//handler，拒绝策略，jdk提供了很多拒绝策略，但是不要去使用，要使用自定义的拒绝策略

                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                        //要自定义拒绝策略，比如后续补偿、记录日志等等都可以在此方法中实现
                        System.out.println("当前的任务已经无法处理，已经拒绝："+r.toString());
                    }
                    
                });
        /* 将Task作为任务，提交线程池操作
         */
        //1 定义6个任务
        Task t1 = new Task(1);
        Task t2 = new Task(2);
        Task t3 = new Task(3);
        Task t4 = new Task(4);
        Task t5 = new Task(5);
        Task t6 = new Task(6);
        
        /* 线程池提交任务的方法有两种
         * 1.execute()无返回值的方法,针对任务没有返回值则使用；
         * 2.submit()有返回值的方法，针对任务有返回值使用，返回一个Future对象(即异步处理，处理完成后获得结果)
        pool.execute(t1);
        pool.submit(t1);
         */
        
        /* 在使用有界队列时，
         * 1 若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程;
         * 2 若大于corePoolSize，则会将任务加入队列;
         * 3 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程,并执行该任务;
         * 4 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。 
         */
        
        //1 若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程;
        pool.execute(t1);  //现在线程池中的核心线程为1，所有提交t1任务符合第一个特性；
        //2 若大于corePoolSize，则会将任务加入队列，进入阻塞等待;
        pool.execute(t2); //在提交t2和t3任务时，已经大于初始化线程，所有会将其加入队列中，定义的队列容量为2未超过new ArrayBlockingQueue<>(2)
        pool.execute(t3);
        //3 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程,并执行该任务;
        pool.execute(t4); //线程池中总线程为2，maximumPoolSize = 3  继续提交t4和t5任务时，已经大于队列容量，会创建新线程并执行t4和t5任务
        pool.execute(t5); //线程池中总线程为3，maximumPoolSize = 3  
        //4 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
        pool.execute(t6); //启动拒绝策略
        
        //线程池执行完毕必须要关闭
        pool.shutdown();
    }

}
/* 1.使用有界队列输出结果：
 * run task id: 1
   run task id: 5
   当前的任务已经无法处理，已经拒绝：当前线程ID：6
   run task id: 4
   run task id: 2
   run task id: 3
 * 前四个会同时执行返回结果，
 * 后面2、3线程被存放在有界队列中，所有当有线程释放后才会执行完成
 */

•JDK支持线程池的拒绝策略：（实际工作中不推荐使用JDK拒绝策略）

•AbortPolicy：直接抛出异常阻止系统正常工作。

•CallerRunsPolicy：只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。

•DiscardOldestPolicy：丢弃最老的一个请求，尝试再次提交当前任务。

•DiscardPolicy：丢弃无法处理的任务，不给予任何处理。

•如果需要自定义拒绝策略可以实现RejectedExecutionHandler接口。

•RejectedExecutionHandler 接口：