目录
1.线程池的优点:
- 线程是稀缺资源,使用线程池可以减少创建和销毁线程的次数,每个工作线程都可以重复使用。
- 可以根据系统的承受能力,调整线程池中工作线程的数量,防止因为消耗过多内存导致服务器崩溃。
2.线程池的实现原理:
提交一个任务到线程池中,线程池的处理流程如下:
1> 判断线程池里的核心线程是否都在执行任务,如果不是(核心线程空闲或者还有核心线程没有被创建)则创建一个新的工作线程来执行任务。如果核心线程都在执行任务,则进入下个流程。
2> 线程池判断工作队列是否已满,如果工作队列没有满,则将新提交的任务存储在这个工作队列里。如果工作队列满了,则进入下个流程。
3> 判断线程池里的线程是否都处于工作状态,如果没有,则创建一个新的工作线程来执行任务。如果已经满了,则交给饱和策略来处理这个任务。
2.1 ThreadPoolExecutor执行示意图
上图说明:
1、如果线程池中的线程数量少于corePoolSize,就创建新的线程来执行新添加的任务
2、如果线程池中的线程数量大于等于corePoolSize,但队列workQueue未满,则将新添加的任务放到workQueue中
3、如果线程池中的线程数量大于等于corePoolSize,且队列workQueue已满,但线程池中的线程数量小于maximumPoolSize,则会创建新的线程来处理被添加的任务
4、如果线程池中的线程数量超出了maximumPoolSize,就用RejectedExecutionHandler.rejectedExecution()方法来执行拒绝策略
总结:ThreadPoolExecutor采取上述的总体设计思路,就是为了在执行execute方法时,尽可能地避免获取全局锁,当运行的线程数大于等于corePoolSize时,几乎所有的excute()都会执行步骤2,而步骤2而不需要获取全局锁,步骤3是需要加锁创建的。
源码:
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
//如果线程数大于等于基本线程数或者线程创建失败,将任务加入队列
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
//线程池处于运行状态并且加入队列成功
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
}
//线程池不处于运行状态或者加入队列失败,则创建线程(创建的是非核心线程)
else if (!addIfUnderMaximumPoolSize(command)) //这个方法里面会加锁
//创建线程失败,则采取阻塞处理的方式
reject(command); // is shutdown or saturated
}
}
}
3.线程池的使用
我们可以通过ThreadPoolExecutor来创建线程池
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,
long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,RejectedExecutionHandler handler);
ThreadPoolExecutor有多个构造器,不一定全部参数都包含,没有包含的使用默认值,以下是参数说明:
- corePoolSize:核心线程池的线程数量
- maximumPoolSize:最大的线程池线程数量
- keepAliveTime:线程活动保持时间,线程池的工作线程空闲后,保持存活的时间,一般都是0
- unit:线程活动保持时间的单位。
TimeUnit.DAYS; //天
TimeUnit.HOURS; //小时
TimeUnit.MINUTES; //分钟
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //纳秒
- workQueue:指定任务队列所使用的阻塞队列,当然不仅仅只有下面三个阻塞队列,有优先级的可以考虑PriorityBlockingQueue,建议使用有界队列,否则后面无界的话不停的创建线程,容易撑爆内存
阻塞队列相关知识,可以参考我的https://blog.csdn.net/weixin_40792878/article/details/81516283
ArrayBlockingQueue; //基于数组的有界阻塞队列
LinkedBlockingQueue;//基于链表的阻塞队列,此队列吞吐量高于ArrayBlockingQueue,静态工厂Executors.newFixedThreadPool()默认使用的这个队列,默认队列长度是Integer.MAX_VALUE
SynchronousQueue; //一个不会存储元素的阻塞队列,吞吐量高于LinkedBlockQueue,静态工厂Executors.newCachedThreadPool()默认使用的这个队列
- ThreadFactory:线程工厂,主要用来创建线程;
- handler:当队列和线程池都满了,说明线程池处于饱和状态,那么必须对新提交的任务采用一种特殊的策略来进行处理,默认是AbortPolicy,这四个都是ThreadPoolExecutor的静态内部类,这几个类都是是实现RejectedExecutionHandler接口的
hanler有以下四种取值:
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常,这是默认的策略
ThreadPoolExecutor.DiscardPolicy:也是丢弃任务,但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新尝试执行任务(重复此过程)
ThreadPoolExecutor.CallerRunsPolicy:由调用者所在线程处理该任务
我们现在用第四种策略来处理上面的程序例子:
public static void main(String[] args){
LinkedBlockingQueue<Runnable> queue =
new LinkedBlockingQueue<Runnable>(3);
RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardPolicy();
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 5, 60, TimeUnit.SECONDS, queue,handler);
for (int i = 0; i < 9 ; i++){
threadPool.execute(
new Thread(new ThreadPoolTest(), "Thread".concat(i + "")));
System.out.println("线程池中活跃的线程数: " + threadPool.getPoolSize());
if (queue.size() > 0){
System.out.println("----------------队列中阻塞的线程数" + queue.size());
}
}
threadPool.shutdown();
}
执行结果:
线程池中活跃的线程数: 1
线程池中活跃的线程数: 2
线程池中活跃的线程数: 2
----------------队列中阻塞的线程数1
线程池中活跃的线程数: 2
----------------队列中阻塞的线程数2
线程池中活跃的线程数: 2
----------------队列中阻塞的线程数3
线程池中活跃的线程数: 3
----------------队列中阻塞的线程数3
线程池中活跃的线程数: 4
----------------队列中阻塞的线程数3
线程池中活跃的线程数: 5
----------------队列中阻塞的线程数3
线程池中活跃的线程数: 5
----------------队列中阻塞的线程数3
这里采用了丢弃策略后,就没有再抛出异常,而是直接丢弃。在某些重要的场景下,可以自定义处理策略,采用记录日志或者存储到数据库中,而不应该直接丢弃。
4.向线程池提交任务
有两个方法提交,一个是execute()方法和submit()方法。
差别 | execute() | submit() |
方法定义 | 在ThreadPoolExecutor中实现,父类 | |
返回值 | 用于提交不需要返回值的任务,所以无法判断任务是否被执行成功 | 方法用于提交需要返回值的任务,线程池返回一个future类型的对象,通过这个future对象你可以判定是否执行成功,可以通过future的get()获取返回值,get()方法会阻塞当前线程,直到完成任务为止,使用get(lont timeout,TimeUnit unit)可以阻塞一定的时间立即返回。这时候线程任务可能没有完成 |
ThreadPoolExecutor中实现的execute实现的方法见上面所示,接口Exeutor中定义如下:
public interface Executor {
void execute(Runnable command); //这是这个接口定义的唯一一个方法
}
AbstractExecutorService中的submit方法,有三种重载方法,源码:
public abstract class AbstractExecutorService implements ExecutorService {
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}
}
5.关闭线程池
可以通过调用线程池的shutdown或者shutdownNow方法关闭线程池,他们的原理都是遍历线程池中的工作线程,然后逐个调用线程的interrupt方法来中断线程,所以无法响应中断的任务可能永远无法终止,两者的差别:
- shutdownNow首先将线程池的状态设置成STOP,然后尝试停止所有的正在执行或者暂停任务的线程,并返回等待执行任务的列表;
- shutdown只是将线程池的状态设置为SHUTDOWN状态,然后中断所有没有正在执行任务的线程。
只要调用了这两个关闭方法的任意一个,isShutDown方法就会返回true,当所有的任务都已经关闭后,才表示线程池关闭成功,这时调用isTerminaed方法会返回true,至于应该调用那一个方法,可以根据线程池的特性来决定,通常用shutdown方法调用关闭线程池,如果任务不一定执行完,则可以调用shutdownNow。
6.线程池提供方法可以重写
这几个是ThreadPoolExecutor提供的未实现的方法,可以通过重写他们在任务执行前,执行后和线程池关闭前执行一些代码来进行监控。
protected void beforeExecute(Thread t, Runnable r) { }
protected void afterExecute(Runnable r, Throwable t) { }
protected void terminated() { }
7.监控线程池,自定义线程池
package com.vison.ws;
import java.util.Date;
import java.util.concurrent.*;
public class MyThreadPoolExecutor extends ThreadPoolExecutor {
private ConcurrentHashMap<String, Date> startTime = new ConcurrentHashMap<String, Date>(); //记录当时的运行时间
public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
}
public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
}
public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
}
//运行之前
@Override
protected void beforeExecute(Thread t, Runnable r) {
startTime.put(String.valueOf(r.hashCode()),new Date()); //把当前任务的hashCode作为键存储,值作为当前时间
super.beforeExecute(t, r);
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
//计算任务执行时间
Date startDate = startTime.remove(String.valueOf(r.hashCode()));
long timeWaste = new Date().getTime() - startDate.getTime();
System.out.println("任务耗时:"+timeWaste);
System.out.println("最大线程数:"+this.getMaximumPoolSize());
super.afterExecute(r, t);
}
//关闭的时候
@Override
public void shutdown() {
System.out.println("已经执行的任务数量:"+this.getCompletedTaskCount()+"\n");
System.out.println("当前活动的线程数:"+this.getActiveCount()+"\n");
System.out.println("当前排队的线程数:"+this.getQueue().size()+"\n");
super.shutdown();
}
//自定义线程池的创建,当然可以通过 自定义线程池工厂,自定义自己的专属的线程名
public static ExecutorService newMyExecutorService(){
return new ThreadPoolExecutor(1,2,0L,TimeUnit.MILLISECONDS,new LinkedBlockingQueue(20));
}
}