线程池常用几种方式

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


/**
 * 1，直接提交队列：SynchronousQueue队列，提交的任务不会被保存，总是会马上提交执行。
 * 2，有界任务队列:ArrayBlockingQueue，有任务对时候直接创建线程，如果thread 数量大于 corePoolSize，则将新的任务加入到等待队列ArrayBlockingQueue中(有初始化大小)，如果等待队列已满，则继续创建线程，如果数量 大于 maximumPoolSize，则执行拒绝策略。
 * 3，无界的任务队列：LinkedBlockingQueue,线程池的任务可以无限制的添加新的任务，而线程池创建对最大线程数量就是corePoolSize的数量，此处maximumPoolSize参数无效，超出corePoolSize数量的新任务都是进入任务队列。
 * 4，优先任务队列：PriorityBlockingQueue它其实是一个特殊的无界队列,线程池创建的线程数也不会超过corePoolSize的数量，只不过其他队列一般是按照先进先出的规则处理任务，而PriorityBlockingQueue队列可以自定义规则根据任务的优先级顺序先后执行
 * @Description: 
 * @author: zhangjianshou  
 * @date: 2019年9月9日 下午2:28:20
 */
public class ThreadPool1 {

    private static ThreadPoolExecutor pool;

    public static void main(String[] args) {
        /**
         * int corePoolSize, 指定了线程池中的线程数量，它的数量决定了添加的任务是开辟新的线程去执行，还是放到workQueue任务队列中去；
         * int maximumPoolSize, 指定了线程池中的最大线程数量，这个参数会根据你使用的workQueue任务队列的类型，决定线程池会开辟的最大线程数量；
         * long keepAliveTime, 当线程池中空闲线程数量超过corePoolSize时，多余的线程会在多长时间内被销毁；
         * TimeUnit unit, 
         * BlockingQueue<Runnable> workQueue, 任务队列，被添加到线程池中，但尚未被执行的任务；它一般分为直接提交队列、有界任务队列、无界任务队列、优先任务队列几种；
         * ThreadFactory threadFactory, 线程工厂，用于创建线程，一般用默认即可；
         * RejectedExecutionHandler handler, 拒绝策略；当任务太多来不及处理时，如何拒绝任务；
         */
        
        // maximumPoolSize设置为2 ，拒绝策略为AbortPolic策略，直接抛出异常
        /**
         * 第一种
         */
        //  pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>(),
        //  Executors.defaultThreadFactory(), new MyRejectedExecutionHandler());
        /**
         * 第二种
         * ArrayBlockingQueue，初始容量5
         */
        pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(5),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        
        /**
         * 第三种
         */
        //   pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(),
        //   Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 3; i++) {
            pool.execute(new ThreadTask());
        }
    }
}

class ThreadTask implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

/**
 * @Description: 拒绝策略，直接调用当前调用者线程资源 来执行run方法
 * @author: zhangjianshou  
 * @date: 2019年9月9日 下午4:34:27
 */
class MyRejectedExecutionHandler implements RejectedExecutionHandler {

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // TODO Auto-generated method stub
       System.out.println("拒绝策略);
       r.run();
    }
}