文章目录

一、ThreadPool线程池状态
二、ThreadPoolExecutor构造方法
三、Executors
- 3.1 固定大小线程池
- 3.2 带缓冲线程池
- 3.3 单线程线程池
四、ThreadPoolExecutor
- 4.1 execute(Runnable task)方法使用
- 4.2 submit()方法
- 4.3 invokeAll()
- 4.4 invokeAny()
- 4.5 shutdown()
- 4.6 shutdownNow()
总结

一、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构造方法

java">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

拒绝策略

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

三、Executors

3.1 固定大小线程池

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

特点

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

3.2 带缓冲线程池

java">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 单线程线程池

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

区别

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

四、ThreadPoolExecutor

4.1 execute(Runnable task)方法使用

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

java">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方法后可以将处理结果进行返回

java">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()

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

java">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()

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

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