线程池的作用
- 管理控制：首先，从管理角度就是为了更好的控制线程，使用线程池来帮助我们去管理线程，使得我们对线程的生命周期、初始化、运行状态、销毁等各个环节有一个把控
- 系统资源：另外一点，从系统资源的角度考虑，线程池可以控制线程的数量，根据任务的多少去对线程池中的线程个数进行添加或者减少，可以回收空闲状态的线程，减少线程的频繁初始化和销毁，避免不必要的系统开销，节省系统资源，保障稳定性
- 应用性能：从性能的角度去考虑，线程池可以配合高并发容器的设置，对任务和工作项进行缓存，异步的多线程的去处理任务，从而提高应用服务的吞吐率、消费性能，也从而提高单个线程的利用率
- 兜底策略：从健壮性的角度去分析，线程池提供了很多拒绝策略，我们在任务过多或者处理不过来的时候，可以进行有效的拒绝策略、降级方案，以补偿的形式进行处理任务，避免因为线程池的问题对系统产生较为严重的影响
Executor
- 为了更好的控制多线程，JDK提供了一套线程框架Executors，帮助开发人员有效地进行线程控制。
- 它们都在java.util.concurrent包中，是JDK并发包的核心。
- Executors，他扮演这线程工厂的角色，我们通过Executors可以创建特定功能的线程池
Executor创建线程的方法
- newFixedThreadPool()方法：该方法返回一个固定数量的线程池，该方法的线程数始终不变，当有一个任务提交时，若线程池中空闲，则立即执行，若没有，则会被暂缓在一个任务队列中等待有空闲的线程去执行
- newSingleThreadExcutor ()方法：创建一个线程的线程池，若空闲则执行，若没有空闲线程则暂缓在任务列队中
- newCachedThreadPool()方法：返回一个可根据实际情况调整线程个数的线程池，不限制最大线程数量，若有任务，则创建线程，若无任务则不创建线程。如果没有任务则线程在60s后自动回收（空闲时间60s），也可以认为指定销毁时间
- newScheduledThreadPool()方法：该方法返回一个SchededExecutorService对象，但该线程池可以指定线程的数量
package com.example.core.pool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class UseExecutors {
public static void main(String[] args) {
ExecutorService executorService1 = Executors.newFixedThreadPool(6);
ExecutorService executorService2 = Executors.newSingleThreadExecutor();
ExecutorService executorService3 = Executors.newCachedThreadPool();
ScheduledExecutorService executorService4 = Executors.newScheduledThreadPool(1);
executorService4.scheduleWithFixedDelay(new Task(1),5,2, TimeUnit.SECONDS);
}
}
package com.example.core.pool;
public class Task implements Runnable{
private int taskId;
public Task(int taskId){
this.taskId = taskId;
}
public int getTaskId() {
return taskId;
}
public void setTaskId(int taskId) {
this.taskId = taskId;
}
@Override
public void run(){
System.out.println("run task id:"+this.taskId);
try{
Thread.sleep(3000);
}catch(InterruptedException e){
e.printStackTrace();
}
}
public String toString(){
return "当前线程的ID:"+this.taskId;
}
}
自定义线程池
- 若Executors工厂无法满足我们的需求，可以自己创建自定义线程池，其实Executors工厂类里面的创建线程方法其内部实现均是用了ThreadPoolExecutor这个类，这个类可以自定义线程。构造方法如下
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
有界队列
- 队列类型参数选择： 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，若大于corePoolSize，则会将任务加入队列，若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式
- 需要配合上面的Task.java使用
package com.example.core.pool;
import java.util.concurrent.*;
public class UseThreadPoolExecutor {
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(
1,
3,
60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(2),
new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread th = new Thread(r, "order-thread");
if (th.getPriority() != Thread.NORM_PRIORITY) {
th.setPriority(Thread.NORM_PRIORITY);
}
if (th.isDaemon()) {
th.setDaemon(false);
}
return th;
}
},
new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("当前的任务已经拒绝："+r.toString());
}
}
);
Task t1 = new Task(1);
Task t2 = new Task(2);
Task t3 = new Task(3);
Task t4 = new Task(4);
Task t5 = new Task(5);
Task t6 = new Task(6);
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
pool.shutdown();
}
}
无界队列
- 在使用无界队列时：LinkedBlockingQueue。与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败的情况。当有新任务到来，系统的线程数小于corePoolSize时，则新建线程执行任务。当达到corePoolSize后，就不会继续增加。若后续仍有新的任务加入，而有没有空闲的线程资源，则任务直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统内存
- 无界队列，只和corePoolSize有关，如果corePoolSize=2，则每次处理两个任务，多余的进入等待序列
package com.example.core.pool;
import java.util.concurrent.*;
public class UseThreadPoolExecutor {
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(
2,
3,
60,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(),
new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread th = new Thread(r, "order-thread");
if (th.getPriority() != Thread.NORM_PRIORITY) {
th.setPriority(Thread.NORM_PRIORITY);
}
if (th.isDaemon()) {
th.setDaemon(false);
}
return th;
}
},
new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("当前的任务已经拒绝："+r.toString());
}
}
);
Task t1 = new Task(1);
Task t2 = new Task(2);
Task t3 = new Task(3);
Task t4 = new Task(4);
Task t5 = new Task(5);
Task t6 = new Task(6);
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
pool.shutdown();
}
}
