线程池是Java中用于高效管理线程的容器，避免频繁创建和销毁线程带来的开销。常见线程池包括可缓存线程池、定长线程池、周期定长线程池和单线程线程池。ThreadPoolExecutor是线程池的实现类，其构造参数如corePoolSize、maximumPoolSize等决定了线程池的行为。线程池通过工作队列和饱和策略来处理任务，提供灵活性和性能优化。
线程池
什么是线程池
线程池（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());
}
扫一扫
169万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
