---

一、ThreadPool线程池状态

ThreadPoolExecutor使用int的高3位来表示线程池状态,低29位表示线程数量

从数字上比较，TERMINATED>TIDYING>STOP>SHUTDOWN>RUNNING，最高的1位是1是代表的是负数
这些信息存储在一个原子变量ctl中，目的是将线程池状态与线程个数合二为一，这样就可以用一次CAS原子操作进行赋值

c为旧值，ctlOf返回结果为新值

ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))

rs(running state)为高3位代表线程池状态 wc(worker count) 为低29位代表线程个数

private static int ctlOf(int rs,int wc){return rs | wc;}

二、ThreadPoolExecutor构造方法

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

ThreadPoolExecutor7大核心参数
corePoolSize：核心线程数目(最多保留的线程数)
maximumPoolSize：最大线程数目
keepAliveTime：生存时间(针对非核心线程)
unit：时间单位(针对非核心线程)
workQueue：阻塞队列
threadFactory：线程工厂
handler：拒接策略
非核心线程数=maximumPoolSize-corePoolSize

拒绝策略

1. AbortPolicy：让调用者抛出RejectedException异常(默认拒绝策略)
2. CallerRunsPolicy：让调用者运行任务
3. DiscardPolicy：放弃本次任务
4. DiscardOldestPolicy：放弃队列中最早的任务，本任务会取而代之

三、Executors

3.1 固定大小线程池

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

特点

1. 核心线程数=最大线程数，因此不需要超时时间
2. 阻塞队列是无界的，可以放任意数量的任务

3.2 带缓冲线程池

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

特点
1. 核心线程=0，最大线程数=Integer的最大值，非核心线程空闲的生存时间是60S
2. 全员都是非核心线程
3. 非核心线程可以无线创建
4. SynchronousQueue实现特点，它没有容量，没有线程来取是放不进去的（一手交钱，一手交货）

3.3 单线程线程池

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

区别

1. 自己创建一个单线程串行执行任务，如果执行任务失败而终止那么没有任何补救措施，而线程池还会重新创建一个线程，保证线程池的工作

四、ThreadPoolExecutor

4.1 execute(Runnable task)方法使用

特点：execute(Runnable task)方法执行后不会返回结果，若我们执行完方法后需要结果进行运算则不适用

public static void main(String[] args) throws Exception{
        ExecutorService pool = Executors.newFixedThreadPool(1);
        //方式一
        pool.execute(new Runnable() {
            @Override
            public void run() {
                //执行的业务逻辑
            }
        });
        //方式二：使用lambda表达式简化
        pool.execute(() -> {
            //执行的业务逻辑
        });
    }

4.2 submit()方法

特点：我们执行完submit方法后可以将处理结果进行返回

public static void main(String[] args) throws Exception{
        ExecutorService pool = Executors.newFixedThreadPool(1);
        //方式一
        Future<返回结果类型> taskResult=pool.submit(new Callable<返回结果类型>() {
            @Override
            public 返回结果类型 call() {
                //执行的业务逻辑,后将处理结果返回
                return null;
            }
        });
        //拿到返回的结果
        taskResult.get();
        
        //方式二：使用lambda表达式简化
        Future<返回结果类型> taskResult=pool.submit(() -> {
            //执行的业务逻辑
            return null;
        });
        //拿到返回的结果
        taskResult.get();
    }

4.3 invokeAll()

特点：执行任务以集合的方式，并且返回结果集合

public static void main(String[] args) throws Exception{
        ExecutorService pool = Executors.newFixedThreadPool(1);
        List<Future<Object>> tasks = pool.invokeAll(Arrays.asList(
                () -> {
	                //执行逻辑返回结果
                    return 1;
                },
                () -> {
                	//执行逻辑返回结果
                    return 2;
                }
        ));
        for (Future<Object> task : tasks) {
            System.out.println(task.get());
        }
    }

4.4 invokeAny()

特点：将任务集合中所有的任务进行执行，只返回第一个执行完毕的任务结果

Integer res = pool.invokeAny(Arrays.asList(
                () -> {
                    return 1;
                },
                () -> {
                    return 2;
                }
        ));
        System.out.println(res);

4.5 shutdown()

特点：

1. 将线程池状态变为SHUTDOWN

• 不会接受新任务
• 但已提交的任务会执行完
• 此方法不会阻塞调用线程的执行

4.6 shutdownNow()

特点：

1. 线程池状态变为STOP

• 不会接收新任务
• 会将队列中的任务返回
• 并用interrupt的方式终端正在执行的任务

---

总结

完