线程池创建的核心:1.三大方法 2.七大参数 3.四大拒绝策略

  线程池创建的核心:
三大方法:
1.Executors.newSingleThreadExecutor();
2.Executors.newFixedThreadPool(5);
3.Executors.newCachedThreadPool();
七大参数:(自定义创建线程池)
1.核心线程数
2.最大线程数
3.等待时间
4.等待时间单位
5.阻塞队列
6.线程池创建工场
7.拒绝策略
四大拒绝策略:
AbortPolicy; 队列和线程池满了之和就会抛出异常
CallerRunsPolicy; 哪来的回哪里去
DiscardOldestPolicy; 满了之后不会抛出异常,丢掉任务
DiscardPolicy 满了之后尝试竞争第一个,失败也不抛异常

线程池最大值如何设置:
1.CPU密集型
System.out.println(Runtime.getRuntime().availableProcessors());
获得cpu的核数,不同的硬件不一样
2.IO密集型
大型的程序任务有多少个? IO非常消耗资源
线程池最大值 > 大型任务的数量即可
一般设置大型任务的数量*2

package cn.pw.demo01;

import java.util.concurrent.*;


/*  线程池创建的核心:
*       三大方法:
*           1.Executors.newSingleThreadExecutor();
*           2.Executors.newFixedThreadPool(5);
*           3.Executors.newCachedThreadPool();
*       七大参数:(自定义创建线程池)
*           1.核心线程数
*           2.最大线程数
*           3.等待时间
*           4.等待时间单位
*           5.阻塞队列
*           6.线程池创建工场
*           7.拒绝策略
*       四大拒绝策略:
*           AbortPolicy;  队列和线程池满了之和就会抛出异常
            CallerRunsPolicy;  哪来的回哪里去
            DiscardOldestPolicy;  满了之后不会抛出异常,丢掉任务
            DiscardPolicy  满了之后尝试竞争第一个,失败也不抛异常

* 线程池最大值如何设置:
*   1.CPU密集型
*        System.out.println(Runtime.getRuntime().availableProcessors());
*        获得cpu的核数,不同的硬件不一样
*   2.IO密集型
*       大型的程序任务有多少个? IO非常消耗资源
*       线程池最大值 > 大型任务的数量即可
*       一般设置大型任务的数量*2
*
* * */
public class Test07ThreadPool {
    public static void main(String[] args) {

        //单线程池
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        //创建一个线程池中可以有5条线程
//        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        //缓存线程池,不固定大小
//        ExecutorService threadPool = Executors.newCachedThreadPool();


//        try {
//            for (int i = 0; i < 50; i++) {
//                threadPool.execute(()->{
//                    System.out.println(Thread.currentThread().getName()+"ok");
//                });
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            //关闭线程池
//            threadPool.shutdown();
//        }

        //源生的线程池创建

//    public ThreadPoolExecutor(int corePoolSize,//核心线程数
//        int maximumPoolSize,  //最大线程数
//        long keepAliveTime, //空闲线程的等待时间
//        TimeUnit unit, //时间单位
//        BlockingQueue<Runnable> workQueue //线程队列 ) {
//            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
//                    Executors.defaultThreadFactory(), defaultHandler);
//        }

//        四种拒绝策列
//       AbortPolicy;  队列和线程池满了之和就会抛出异常
//       CallerRunsPolicy;  哪来的回哪里去
//       DiscardOldestPolicy;  满了之后不会抛出异常,丢掉任务
//       DiscardPolicy  满了之后尝试竞争第一个,失败也不抛异常
            ThreadPoolExecutor threadPool= new ThreadPoolExecutor(
                    2,//核心线程数
                    Runtime.getRuntime().availableProcessors(),//最大线程数
                    3,//等待时间
                    TimeUnit.SECONDS,//时间单位
                    new LinkedBlockingQueue<>(3),//等待队列
                    Executors.defaultThreadFactory(),//默认线程工场,一般不改变
                    new ThreadPoolExecutor.DiscardOldestPolicy()//线程和队列满了的拒绝策列
                    );

            try {
                //线程池大小= 最大线程数+ 阻塞队列大小
                for (int i = 1; i <= 9; i++) {
                    threadPool.execute(()->{
                        System.out.println(Thread.currentThread().getName()+"ok");
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //关闭线程池
                threadPool.shutdown();
            }

    }
}

 



上一篇:1、Task的优势


下一篇:thread threadpool task