线程池的七大参数

1.看一下三大方法的底层源码，都是调用了ThreadPoolExecutor

2.来看一下ThreadPoolExecutor底层源码

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

七大参数理解：

• corePoolSize：核心线程数。在创建了线程池后，线程中没有任何线程，等到有任务来时，才创建线程去执行任务。默认情况下，线程池的线程数量为0，只有任务来时，才会创建线程，当线程池中的线程数量达到corePoolSize，就会把达到的放到缓存队列当中。
• maximumPoolSize：最大核心线程数。表明线程池中能创建的最大数量，此值必须大于等于1
• keepAliveTime：空闲的线程保留时间。意思是线程被用过之后，一定时间没有再用后，就会自动放回线程池。
• TimeUnit unit：空闲线程保留时间的单位
• BlockingQueue：阻塞队列，存储等待执行的任务。参数有ArrayBlockingQueue、
  LinkedBlockingQueue、SynchronousQueue可选。
• ThreadFactory ：线程工程，创建线程的，一般默认即可
• RejectedExecutionHandler ：拒绝策略。队列已满，而且任务量大于最大线程的异常处理策略。有以下取值

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务 （重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

银行取钱

1-2个人被受理（核心线程core）
3-5个人进入队列（queue）
6-8个人进入最大线程池（扩容大小max）
超过8个人触发拒绝策略

执行流程

• 1.创建一个线程池，等待执行任务
• 2.来了一个请求任务，如果正在运行的线程数量小于corePoolSize，那么就会立即创建一个线程来执行任务。
• 3.如果正在运行的线程数量大于或者等于corePoolSize，那么将这个任务放入队列。
• 4.如果这时候队列满了，且当前的线程数量小于maximumPoolSize，那么就会创建非核心线程来执行任务，进行扩容
• 5.如果队列满了，且当前线程的数量大于maximumPoolSize，那么就会触发拒绝策略
• 6.当一个线程完成时，他会从队列中取下一个任务来执行
• 7，当一个线程完成任务后，队列中也没有任务时，到达一定时间keepAliveTime，这个线程就会被停掉

import java.util.concurrent.*;

public class Test2 {
    public static void main(String[] args) {
        //获取CPU的核数
        System.out.println(Runtime.getRuntime().availableProcessors());
        //自定义线程池
        /*
        * 最大线程到底该如何定义：
        * 1.CPU密集型：几核，就是几，可以保持CPU的效率最高
        * 2.IO密集型：   >判断你程序中十分耗IO的线程
        * 程序   15个大型任务，十分占用资源
        * */
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                new ThreadPoolExecutor.AbortPolicy()
        );

        try {
            for (int i=1;i<=2;i++){
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"--->执行");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

思考题：线程是否越多越好？

一个计算为主的程序（专业一点称为CPU密集型程序）。多线程跑的时候，可以充分利用起所有的cpu核心，比如说4个核心的cpu,开4个线程的时候，可以同时跑4个线程的运算任务，此时是最大效率。但是如果线程远远超出cpu核心数量 反而会使得任务效率下降，因为频繁的切换线程也是要消耗时间的。
因此对于cpu密集型的任务来说，线程数等于cpu数是最好的了。
如果是一个磁盘或网络为主的程序（IO密集型）。一个线程处在IO等待的时候，另一个线程还可以在CPU里面跑，有时候CPU闲着没事干，所有的线程都在等着IO，这时候他们就是同时的了，而单线程的话此时还是在一个一个等待的。我们都知道IO的速度比起CPU来是慢到令人发指的。所以开多线程，比方说多线程网络传输，多线程往不同的目录写文件，等等。
此时 线程数等于IO任务数是最佳的。