Java并发编程4——Executor / ExecutorService / ThreadPoolExecutor线程池

JYY_JYY_

已于 2024-04-11 20:27:54 修改

阅读量280

点赞数

分类专栏： JAVA多线程文章标签： java 开发语言

于 2021-03-29 15:45:35 首次发布

本文链接：https://blog.csdn.net/qq_41157876/article/details/115297036

版权

JAVA多线程专栏收录该内容

12 篇文章 0 订阅

订阅专栏

继承关系
Executor接口（顶层接口）
ExecutorService接口
AbstractExecutorService抽象类
ThreadPoolExecutor实现类
ThreadPoolExecutor
属性
执行方法
线程池状态（5种状态）
构造器（7个参数）
线程池运行机制
阻塞队列workQueue
源码级别
Work类
Executors工具类提供的线程池实现
nexFixedThreadPool：固定大小的线程池
newCachedThreadPool：带缓冲池的线程池
newSingleThreadExecutor：单线程线程池
其他
submit() / invokeAny() / invokeAll()使用示例

4.1 继承关系

Executor接口：顶层接口，只定义了一个execute(Runnable)方法

void execute(Runnable command)

任务执行方法
可能会抛出异常
- RejectedExecutionException：任务被线程池拒绝
- NullPointerException：Runnable对象为null

ExecutorService接口：继承了Executor接口，定义了两种方法：生命周期管理的相关方法，任务提交的方法：submit()，invokeAll() / invokeAny()

生命周期管理的相关方法（只定义接口方法，实现方法全部由ThreadPoolExecutor实现）	void shutdown();	把线程池状态设置成SHUTDOWN 正在执行的线程继续执行队列中的也会执行完，但不再接受新任务
	List<Runnable> shutdownNow();	把线程池状态设置成STOP 正在执行的任务立刻终止没有执行的任务队列返回
	boolean awaitTermination(long timeout, TimeUnit unit)	代码运行到这个方法会被阻塞，两种情况会放行线程池状态为TERMINATED（比如执行了shutdown方法之后）阻塞时间超过timeout之后，会被放行
	boolean isTerminated(); boolean isShutdown();	线程池状态是否是TERMINATED 线程池状态是否》=SHUTDOWN（SHUTDOWN, STOP, TIDYING, TERMINATED），换句话说：只要不处于RUNNING的线程，都返回true
submit()方法（只定义接口方法，实现方法全部由AbstractExecutorService实现）	Future<?> submit(Runnable task) //无返回值，返回值为null <T> Future<T> submit(Runnable task, T result) //通过传入的result间接获得返回值 <T> Future<T> submit(Callable<T> task) //有返回值	提交任务，用返回值Future获得任务结果三者的源码都是把任务封装成FutureTask对象，扔给execute()方法执行
invokeAll() / invokeAny() （只定义接口方法，实现方法全部由AbstractExecutorService实现）	List<Future<T>> invokeAll(Collection<继承Callable<T>的类> tasks); List<Future<T>> invokeAll(Collection<继承Callable<T>的类> tasks, long timeout, TimeUnit unit);	提交tasks中所有任务
	T invokeAny(Collection<继承Callable<T>的类> tasks); T invokeAny(Collection<继承Callable<T>的类> tasks, long timeout, TimeUnit unit);	提交tasks中所有任务，哪个先执行完哪个先返回结果，其他任务取消

AbstractExecutorService抽象类：继承了ExecutorService接口
- 没什么特别的，实现了submit()方法，invokeAll() / invokeAny()方法，见上
ThreadPoolExecutor实现类：继承AbstractExecutorService抽象类，最常用的线程池实现类，下文分析

4.2 ThreadPoolExecutor

属性

ctl	private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));	状态控制属性高3位表示线程池的运行状态剩下的29位表示当前有效的线程数量
worker相关	private final class Worker 继承AQS，实现Runnable
worker相关	private final HashSet<Worker> workers = new HashSet<Worker>();
锁相关	private final ReentrantLock mainLock = new ReentrantLock(); private final Condition termination = mainLock.newCondition();	独占锁，控制新增Worker操作的原子性中止条件：Condition类
构造器参数相关	private volatile int corePoolSize; private volatile int maximumPoolSize; private volatile long keepAliveTime; private final BlockingQueue<Runnable> workQueue; private volatile ThreadFactory threadFactory; private volatile RejectedExecutionHandler handler;	见下文构造器
静态内部类	static class CallerRunsPolicy; static class AbortPolicy; //默认策略 static class DiscardPolicy; static class DiscardOldestPolicy	都实现了RejectedExecutionHandler，提供饱和策略
监控线程池的属性	private long completedTaskCount：线程池在运行过程中已完成的任务数量 private int largestPoolSize：线程池里曾经创建过的最大线程数量 getPoolSize()：线程池的线程数量 getActiveCount()：获取活动的线程数	可以通过线程池提供的参数进行监控

执行方法：可以使用两个方法向线程池提交任务，分别为execute()和submit()方法
- execute()方法用于提交不需要返回值的任务，无法判断该线程是否已经执行成功
  - 入参是Runnable，不返回结果
- submit(Callable x) 返回一个Future，可以通过Future判断该线程是否执行成功及结果
  - 入参是Callable接口，可以返回结果，并且能抛出异常
- invokeAll(Collection<Callable> x)：一次性提交多个任务，阻塞调用线程直到所有任务执行完毕，然后返回所有Future对象的列表

线程池状态

ThreadPoolExecutor使用AtomicInteger ctl高3位来表示线程池状态，低29位表示线程池数量

状态名	高3位	接受新任务	处理阻塞队列任务	说明
RUNNING	111	Y	Y	刚创建线程池默认状态
SHUTDOWN	000	N	Y	不接受新任务，但会处理阻塞队列剩余任务
STOP	001	N	N	不接受新任务，会中断正在执行的任务，并丢弃阻塞队列中的任务
TIDYING	010	/	/	所有任务都已终止，工作线程数为零，线程转换到状态 TIDYING 将会执行钩子函数 terminated()
TERMINATED	011	/	/	terminated() 执行完毕后，进入终结状态

为何要把线程池状态（3bits）和数量(29bits)合并在一起：保证原子性，即可以只用1次CAS操作进行赋值
从数字上比较TERMINATED(3)>TIDYING(2)>STOP(1)>SHUTDOWN(0)>RUNNING(-1)

构造器 / 参数

public ThreadPoolExecutor(  int corePoolSize,    //核心线程数目（最多保留的线程数）
                            int maxmumPoolSize,     //最大线程数
                            long keepAliveTime,    //生存时间-针对救急线程
                            TimeUnit unit,        //时间单位-针对救急线程
                            BlockingQueue<Runnable> workQueue,  //阻塞队列
                            ThreadFactory threadfactory,    //线程工厂-可以为线程取个好名字
                            RejectedExecutionHandler handler)    //拒绝策略

线程池运行机制
- 1. 线程池刚开始没有线程，当一个任务提交给线程池后，线程池会创建一个新线程来执行任务
- 2. 当线程数达到corePoolSize并且没有线程空闲，这时再加入新任务，新任务会进入workQueue进行排队，直到有空闲线程
- 3. 如果队列选择了有界队列，那么任务超过了队列大小时候，会创建maximumPoolSize- corePoolSize数目的线程来救急
- 4. 如果线程到达maximumPoolSize仍然有新任务，这时会进行拒绝策略，jdk提供了4种实现
  - AbortPolicy（默认策略）：让调用者抛出RejectedExecutionException异常，
  - CallerRunsPolicy：使用调用者所在的线程来执行任务
  - DiscardPolicy：放弃本次任务，不处理，丢弃掉
  - DiscardOldestPolicy：放弃队列中最早的任务，本任务取代之
- 5. 当高峰过去后，超过corePoolSize的急救线程如果一段时间没有任务，需要结束节省资源，时间由keepAliveTime和unit控制
阻塞队列workQueue
- 没有容量的队列
  - SynchronousQueue：不存储元素的队列，线程数到达corePoolSize后直接开始创建新线程，直至到达maximumPoolSize
- 有界队列
  - ArrayBlockingQueue(常用)：数组结构组成的有界阻塞队列（它的容量在初始化时指定，并且在生命周期中不可改变），按FIFO原则
- 无界队列
  - LinkedBlockingQueue(常用)：链表结构组成的可选无界阻塞队列（也可设置成有界队列，取决于初始化时是否指定容量），按FIFO原则，吞吐量通常要高于ArrayBlockingQueue
  - PriorityBlockingQueue：与LinkedBlockingQueue的不同在于，一个根据构造时传入的Comparator进行排序，一个根据FIFO排序
Worker类
- ThreadPoolExecutor类中，一个关键的私有内部类
- 主要特征
  - Worker类的性质：Worker类继承自AbstractQueuedSynchronizer（AQS）并实现了Runnable接口，它使用AQS来控制线程的状态
  - 封装线程：Worker类封装了线程的执行逻辑，每个Worker实例都包含一个Thread对象，它代表了线程池中的一个线程
  - 任务执行：Worker的run方法中会调用外部ThreadPoolExecutor的runWorker方法，这是线程池中执行任务的核心逻辑

4.3 Executors工具类提供的线程池实现

JUC tools下的Executors类提供了几个线程池

（1）nexFixedThreadPool：固定大小的线程池

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

ExecutorService pool = Executors.newFixedThreadPool(2);

pool.executor(()->{
    //任务1
})；

pool.executor(()->{
    //任务2
})；

pool.executor(()->{
    //任务3
})；

特点
- 核心线程数=最大线程数，即没有救急线程，因此也无需超时时间
- 阻塞队列是无界的，可以放任意数量的任务
评价
- 适用于任务数量已知，相对耗时的任务

（2）newCachedThreadPool：带缓冲池的线程池

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

特点
- 核心线程数是0，最大线程数MAX_VALUE，即所有创建的线程都是救急线程（60s后可以回收），救急线程可以无限创建。
- 队列采用了SychronousQueue，实现特点是：没有容量，没有线程来取得时候是放不进去的。
评价
- 整个线程池表现为线程数会根据任务量不断增长，没有上限。当任务执行完毕，空闲线程1分钟后会释放。
- 适合任务数较为密集，但每个任务执行时间较短的情况

（3）newSingleThreadExecutor：单线程线程池

特点
- 希望多个任务排队执行。线程数固定为1，当任务大于1时，会进入无界队列排队。执行完毕后，这唯一的线程也不会释放
- Executors.newSingleThreadExecutor()的线程个数始终为1，不能修改
- 它运用了装饰器模式，返回的是FinalizableDelegatedExecutorService对象不能调用ThreadPoolExecutor中特有的方法
区别
- 对比自己创建的串行执行的单线程任务，如果任务失败会终止。而该线程池会继续往下执行
- 对比Executors.newFixedThreadPool(1)，可以用setCorePoolSize来修改数量

（4）ScheduledThreadPoolExecutor：定时任务线程池

特点：
- 该线程池可以执行定时任务和周期性任务
- 可以通过schedule()方法来提交定时任务
- 通过scheduleAtFixedRate()或scheduleWithFixedDelay()方法来提交周期性任务

4.4 其他

（1）submit示例：

ExecutorService pool = Executors.nexFixedThreadPool(2);



//实例1：submit方法中提供Callable类
Future<String> future = pool.submit(new Callable<String>(){
    
    @Override
    public String call() throws Exception{
        Thread.sleep(1);
        return "123456789";
    }
});

//实例2：利用lambda函数
Future<String> future1 = pool.submit(()->{
    Thread.sleep(1);
    return "987654321";
});

//利用future.get()方法获取返回值
String ans = future.get();
String ans1 = future1.get();

（2）invokeAll()示例：

ExecutorService pool = Executors.newFixedThreadPool(2);

List<Future<String>> futures = pool.invokeAll(Arrays.asList(

    () -> { 
        Thread.sleep(1);
        return "线程1";
    },

    () -> { 
        Thread.sleep(1);
        return "线程2";
    },  

    () -> { 
        Thread.sleep(1);
        return "线程3";
    }
));

for(Future<String> f: futures){
    try{
    System.out.println(f.get());
    }catch(InterruptedException | ExecutionException e){
        e.printStackTrace();
    }
}

（3）invokeAny()示例：

ExecutorService pool = Executors.newFixedThreadPool(3);

String str = pool.invokeAny(Arrays.asList(
    
    () -> { 
        Thread.sleep(3);
        return "线程1";
    },

    () -> { 
        Thread.sleep(2);
        return "线程2";
    },  

    () -> { 
        Thread.sleep(1);
        return "线程3";
    }

));

//str = 线程2；因为线程2先执行完;线程1和线程3会被取消