线程池
什么是线程池
线程池(ThreadPool),听起来就非常的有意思哈。乍一看还以为是将线程放在一个池子中,其实啊,还真是这样,也可以简单的理解为一个可以容纳多个线程的容器。
那么,线程池有啥用呢,和线程相比又有什么特别点呢
线程池的的优势
Java中使用线程的话,除了处理用户的请求之外,时间花的最多的地方就在于创建和销毁线程。而对于线程来说,这两个操作又是必须要做的,而用线程池来代替的话,将线程用线程池来储存着,用到的时候既不用进行创建线程,也不用在结束使用后进行销毁,大大地提高了时间效率。
而且另一方面来说,线程中的切换也是一个需要消耗系统资源的地方,用线程池能很好的解决资源不足问题
线程池的分类
常用线程池主要有以下四种类型:
可缓存线程池(CachedThreadPool):也叫作不定长的线程池,主要优势在于灵活,无论多少线程并发也能承载
定长线程池(FixedThreadPool):优势在于能控制最大的线程并发数量,接下来进入的线程都只能排队等候
周期定长线程池(ScheduledThreadPool):与定长线程池类似,但可以以给定时间为周期执行任务
单线程线程池(SingleThreadPool):同一时间只能容纳一个线程进行任务,后续线程将会进行排队等候
线程池的实现
1、缓存线程池的使用案例:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
public static void main(String[] args) {
ExecutorService es = Executors.newCachedThreadPool();
es.execute(new Runnable() {
@Override
public void run() {
System.out.println("执行该代码");
}
});
}
}
2、定长线程池的使用案例:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
public static void main(String[] args) {
ExecutorService es = Executors.newFixedThreadPool();
es.execute(new Runnable() {
@Override
public void run() {
System.out.println("执行该代码");
}
});
}
}
3、单线程线程池使用案例
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
public static void main(String[] args) {
ExecutorService es = Executors.newSingleThreadExecutor();
es.execute(new Runnable() {
@Override
public void run() {
System.out.println("执行该代码");
}
});
}
}
4、周期定长线程池使用案例:
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class Main {
public static void main(String[] args) {
ScheduledExecutorService es = Executors.newScheduledThreadPool(2);
es.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("执行该代码");
}
},5, ,1,TimeUnit.SECONDS);
}
}
ThreadPoolExecutor
其实,以上四种线程池只是用得较多的几种,被封装好了的线程池,除此之外,也要对线程池的真正实现类ThreadPoolExecutor有所了解。
首先,看一下构造方法:
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
可以看到,该类有四个构造方法,并且其中还有一些参数:
corePoolSize:核心线程数,核心线程指的是即使线程处于空闲状态也不会被回收掉,如:缓存线程池中核心线程池就是0,因为缓存线程池中线程数是不定的,而单线程线程池由于有且只有一个线程,其中核心线程数就是1,其他两个则是参数相关。当变量allowCoreThreadTimeout设置为true时,核心线程也会被回收
maximumPoolSize:线程池最大线程数,当创建线程超过最大线程数时,将会执行饱和策略。
keepAliveTime:线程闲置时长,当非核心线程闲置时间超过时长时,将会被回收。
unit:线程闲置时长的单位。
workQueue:任务队列,往线程池中添加的任务将储存在该队列中
threadFactory:线程工厂,创建新线程时的统一格式。
handler:饱和策略:当线程达到最大线程数时所进行的处理,有以下4种常用的策略:
AbortPolicy(默认策略):丢弃任务并抛出异常;
CallerRunsPolicy:调用线程处理该任务
DiscardPolicy:丢弃任务但不抛出异常,可根据此策略进行扩展自定义策略
DiscardOldestPolicy:丢弃队列中最早的未处理的任务,将新任务执行
除了构造方法,它还有一些常用的普通方法:
public void execute(Runnable command)
该方法给定一个任务,线程池对该任务执行或进行相应的处理
public void shutdown()
启动关闭线程池,已启动的任务将会继续完成,但不接收新的任务
接下来,我们就可以理解四个封装线程池的源码了:
缓存线程池是一个核心线程数为0,最大线程数为整型最大值,且闲置时长 偏长的线程池:
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
定长线程池是一个核心线程数为参数,最大线程数与核心线程数一致,且每个线程无闲置时长的线程池
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
单线程线程池是一个核心线程数及最大线程数都为1的线程池
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
周期定长线程池较为特殊,核心线程数为参数,最大线程数为整型最大值,除了闲置时间之外,他的任务队列是以延时队列进行储存的,时间没到无法提取任务
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}