线程池

概论

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。

线程池的好处

降低资源的消耗
提高响应速度
方便管理
总结：线程复用，可以控制最大线程数，方便管理

//线程池
/**线程池  三大方法   七大参数  四种拒绝方式
 * 线程池的好处
 * 1.降低资源的消耗
 * 2.提高响应的速度
 * 3.方便管理
 * 线程复用，可以控制最大线程数，方便管理
 * */

public class Demo01 {
    public static void main(String[] args) {
        /**
         * 线程池三大方法
         * 能够同时开启的线程数
         * 1.newSingleThreadExecutor() 创建一个单一线程
         *2.newFixedThreadPool(5) 创建一个固定线程，能够同时开启5条线程
         * 3.newCachedThreadPool() 遇强则强，主机的最大同时线程开启数
         */
        //ExecutorService service01= Executors.newSingleThreadExecutor();
        //ExecutorService service02 = Executors.newFixedThreadPool(5);
        ExecutorService service03 = Executors.newCachedThreadPool();
        try {
            for (int i = 1; i <=100 ; i++) {
                //使用了线程池后，通过线程池来创建线程
                service03.execute(()-> System.out.println(Thread.currentThread().getName()+"线程创建成功"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //使用线程池，在程序结束之前要关闭线程池
            service03.shutdown();
        }
    }
}

三大方法

newSingleThreadExecutor() 创建一个单一线程
newFixedThreadPool(5) 创建一个固定线程，能够同时开启5条线程
newCachedThreadPool() 遇强则强，主机的最大同时线程开启数

控制线程开启的线程数

七大参数

  public ThreadPoolExecutor(int corePoolSize,//核心线程池大小
                              int maximumPoolSize,//最大核心线程池大小
                              long keepAliveTime,//超时，没有调用就会释放
                              TimeUnit unit,//超时单位
                              BlockingQueue<Runnable> workQueue,//阻塞队列
                              ThreadFactory threadFactory,//线程工厂，创建线程的，一般不用动
                              RejectedExecutionHandler handler//拒绝策略
                             6) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

四大拒绝策略

new ThreadPoolExecutor.AbortPolicy() //银行满了，还有人进来，不处理这个人，直接抛出异常
new ThreadPoolExecutor.CallerRunsPolicy()//哪来的去哪里
new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢到任务，不会抛出异常
new ThreadPoolExecutor.DiscardOldestPolicy()//队列满了尝试和最早的线程竞争，成功进入，失败丢掉，也不会抛出异常

/** 四大拒绝策略
 *1.new ThreadPoolExecutor.AbortPolicy() //银行满了，还有人进来，不处理这个人，直接抛出异常
 *2.new ThreadPoolExecutor.CallerRunsPolicy()//哪来的去哪里
 *3.new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢到任务，不会抛出异常
 *4.new ThreadPoolExecutor.DiscardOldestPolicy()//队列满了尝试和最早的线程竞争，成功进入，失败丢掉，也不会抛出异常
 */

public class Demo02 {
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                 new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy()
                );
        //最大承载数：Deque+Max
        for (int i = 1; i <=3; i++) {
          threadPool.execute(()-> {
              System.out.println(Thread.currentThread().getName()+": "+"OK");
          });
        }
       threadPool.shutdown();
    }
}