07-线程池(重点)&三大方法&7大参数&4种拒绝策略

13.线程池(重点)

线程池：三大方法 7大参数 4种拒绝策略

池化技术

程序的运行，本质：占用系统的资源！优化资源的使用！==> 池化技术

池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我

线程池的好处

1.降低资源的消耗

2.提高响应的速度

3.方便管理

线程复用，可以控制最大并发数，管理线程

线程池，三大方法

package test03;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//Executors 工具类 3大方法
public class Test1 {
    public static void main(String[] args) {
        ExecutorService threadpool = Executors.newSingleThreadExecutor();//单个线程
       // ExecutorService threadpool = Executors.newFixedThreadPool(5);//创建一个固定的线程池的大小
        //ExecutorService threadpool = Executors.newCachedThreadPool();//可伸缩的，遇强则强，遇弱则弱

        try{
            for (int i = 0; i < 10; i++) {
                //使用了线程池之后，使用线程池来创建线程
                threadpool.execute(()->{
                    System.out.println(
                            Thread.currentThread().getName()+"ok"
                    );
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //线程池用完，程序结束，关闭线程池
            threadpool.shutdown();
        }
    }
}

7大参数

  public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

自定义线程池

package test03;

import java.util.concurrent.*;

/**
 *new ThreadPoolExecutor.AbortPolicy() //银行满了，还有人进来，不处理这个人的，抛出异常
 *new ThreadPoolExecutor.CallerRunsPolicy() //哪里来的回哪去  main线程
 *  new ThreadPoolExecutor.DiscardPolicy()// 队列满了，丢掉任务，不会抛出异常
 * new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的竞争，也不会抛出异常！
 */
public class Test2 {
    public static void main(String[] args) {
   //自定义线程池！ 工作ThreadPoolExecutor
        ExecutorService threadPool=new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );


        try{
            //最大承载 ： Deque+max
            //超过 RejectedExecutionException
            for (int i = 1; i <= 9; i++) {
                //使用了线程池之后，使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(
                            Thread.currentThread().getName()+"ok"
                    );
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //线程池用完，程序结束，关闭线程池
            threadPool.shutdown();
        }
    }
}

四种拒绝策略

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

小结和扩展

池的最大大小如何去设置 (调优)

1. CPU密集型 几核 就是几 可以保持CPU效率最高 
 System.out.println(Runtime.getRuntime().availableProcessors());
 
2. IO密集型  
判断你程序中十分耗IO的线程

---