9.jdk多任务执行框架
文章目录
- 博客概述
- 特定功能的线程池
- 底层代码实现
- ThreadPoolExecutor
- 演示第四种线程池
- 自定义线程池使用详解
-
- 构造方法中的队列类型很关键。
- 队列满了之后的jdk的拒绝策略如下：
- 基于有界队列的自定义线程池代码示例
-
- 主函数
- Task任务
- 基于无界队列的自定义线程池代码示例
- 丢弃策略详解
-
- 代码实现
- 实战经验
博客概述
为了更好的控制多线程，jdk提供了一套线程框架Executor，帮助开发人员有效地进行线程控制。他们都在java.util.concurrent包中，是jdk并发包的核心。其中有一个比较重要的类：Executors，他扮演线程工厂的角色，我们通过Executors可以创建特定功能的线程池。
特定功能的线程池
第一个：固定数量线程池。其他的创建方法类似。如果10个线程，有第11个任务来了，会把11个任务缓存到任务队列中。等到线程有一个忙完了，会处理第11个任务。
第二个：单一线程线程池，理解为第一种线程的定制版。
第一个第二个线程池，任务队列无限长，都是linkedblockingqueue。
第三个：不定长线程池，来多少任务，起多少线程，处理任务期间有线程完成了，会空闲下来，等待60S，60s中有任务来了，他就顶上去处理。如果60s过了，没有任务，这个线程就销毁。如果所有线程都在工作的时候，来了新任务，就启动新的线程去处理。实时性很高，但是对机器要求也高。
第四个：四个静态方法，最后一个比较类似于Timer。可以固定线程的数量。
底层代码实现
对于单线程线程池和固定数量线程池，底层都是一个对象的不同参数构造函数实现的。任务队列只阻塞队列（无限长度）。
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue()));
}
对于可伸缩的线程池，底层代码实现如下，使用了sync队列，意味着是不存储任务的，来了任务就让线程执行，没有线程就新建，导致对机器性能要求高。
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue());
对于定时任务线程池，底层任务队列是延迟队列，以此来实现定时任务的效果。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
看一下ScheduledThreadPoolExecutor的实现是什么：
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}
看一下他的父类：
public class ScheduledThreadPoolExecutor
extends ThreadPoolExecutor
implements ScheduledExecutorService {
也就是说四个静态方法提供的线程池，都是一个对象的不同构造函数设置实现的。这个对象就是：
ThreadPoolExecutor。我们可以直接使用这个来自定义线程池。
ThreadPoolExecutor
要实现自定义线程池，主要是对ThreadPoolExecutor的参数进行配置。
核心线程数（初始化时），
最大线程数，
空闲时间，
时间单位，
自己制定的任务队列（存放来不及处理的任务）（联系那个公路项目三种队列的选择），
自定义线程工厂（创建什么样的线程），
拒绝执行的策略（队列被填满时的处理）（联系那个公路项目拒绝策略）。
演示第四种线程池
代码参数解释：
command：要执行的任务
1：初始化时间，第一次执行的时间
5：轮询时间
TimeUnit：最后是时间单位。
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
class Temp extends Thread {
public void run() {
System.out.println("run");
}
}
public class ScheduledJob {
public static void main(String args[]) throws Exception {
Temp command = new Temp();
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
ScheduledFuture scheduleTask = scheduler.scheduleWithFixedDelay(command, 5, 1, TimeUnit.SECONDS);
}
}
自定义线程池使用详解
构造方法中的队列类型很关键。
- 有界队列，若有新的任务需要执行，如果线程池的实际线程数小于corePoolSize，则优先创建线程，若大于corePoolSize，则会将任务加入任务队列，若队列已满，则在总线程数不大于maxPoolSize的前提下，创建新的线程，若线程数大于maxPoolSize，则执行拒绝策略。或者其他的自定义方式。
- 无界的任务队列，LinkedBlockingQueue，与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败的情况。当有新任务到来的时候，系统的线程数小于corePoolSize，则会创建线程执行任务。当达到poolsize之后，就不会继续增加线程。若后续仍有新的任务加入，而没有空闲的线程资源，则任务直接进入队列等待。若任务处理和创建的速度差异很大，无界队列会快速保持增长，直到耗尽系统内存。
特别注意：对于无界队列，max这个参数没有意义，有限制的只有coresize。为啥没有意义，因为只有在任务队列满了，才会产生当前线程数与max线程数的比较，无界队列不存在满的概念，所以永远不会触发比较，所以，max参数不生效。
队列满了之后的jdk的拒绝策略如下：
- AbortPolicy：直接抛出异常，组织系统正常工作。
- CallerRunsPolicy：只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。
- DiscardOldestPolicy：丢弃最老的一个请求，尝试再次提交当前任务。
- DiscardPolicy：丢弃无法处理的任务，不给予任何处理。
如果需要自定义拒绝策略可以实现RejectedExecutionHandler接口。
基于有界队列的自定义线程池代码示例
主函数
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy;
public class UseThreadPoolExecutor1 {
public static void main(String[] args) {
/**
* 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
* 若大于corePoolSize，则会将任务加入队列，
* 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
* 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
*
*/
ThreadPoolExecutor pool = new ThreadPoolExecutor(
1, //coreSize
2, //MaxSize
60, //60
TimeUnit.SECONDS,
new ArrayBlockingQueue(3) //指定一种队列 （有界队列）
//new LinkedBlockingQueue()
, new MyRejected()
//, new DiscardOldestPolicy()
);
MyTask mt1 = new MyTask(1, "任务1");
MyTask mt2 = new MyTask(2, "任务2");
MyTask mt3 = new MyTask(3, "任务3");
MyTask mt4 = new MyTask(4, "任务4");
MyTask mt5 = new MyTask(5, "任务5");
MyTask mt6 = new MyTask(6, "任务6");
pool.execute(mt1);
pool.execute(mt2);
pool.execute(mt3);
pool.execute(mt4);
pool.execute(mt5);
pool.execute(mt6);
pool.shutdown();
}
}
Task任务
public class MyTask implements Runnable {
private int taskId;
private String taskName;
public MyTask(int taskId, String taskName){
this.taskId = taskId;
this.taskName = taskName;
}
public int getTaskId() {
return taskId;
}
public void setTaskId(int taskId) {
this.taskId = taskId;
}
public String getTaskName() {
return taskName;
}
public void setTaskName(String taskName) {
this.taskName = taskName;
}
@Override
public void run() {
try {
System.out.println("run taskId =" + this.taskId);
Thread.sleep(5*1000);
//System.out.println("end taskId =" + this.taskId);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public String toString(){
return Integer.toString(this.taskId);
}
}
代码执行解析：
- 先执行一个任务。
会看到马上打印，因为初始化就有一个线程，正好来一个任务，干完活（5S之后）线程停止。
然后5秒后线程停止。
shutdown方法是等线程执行完了之后停止。 - 再执行两个任务。
第二个任务会被加入队列。
10S后线程池才停止。
一个线程执行两个任务。 - 三个任务 四个任务，同理。
都是一个线程去做。
此时属于一个初始化线程在运行，队列未满（任务数量>3不成立）。 - 当执行5个任务，线程执行一个，队列里放三个。
第五个会让第二个线程执行。
也就是15秒执行完毕。
第一个五秒 ：两个线程 分别干掉一个任务，剩下三个任务。
第二个五秒：两个线程 分别干掉一个任务，剩下1个任务。
第三个五秒：剩下的一个任务被一个线程处理。剩下0个任务。
总计用时15S。 - 如果是6个任务 ，就会抛出异常。因为此时两个线程都在工作（最大线程数满了），队列里有三个任务满负载（任务队列满了），没有地方放第六个任务，就报错了。
基于无界队列的自定义线程池代码示例
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class UseThreadPoolExecutor2 implements Runnable{
private static AtomicInteger count = new AtomicInteger(0);
//里面用了原子类，就可以不加锁了
@Override
public void run() {
try {
int temp = count.incrementAndGet();
System.out.println("任务" + temp);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception{
//System.out.println(Runtime.getRuntime().availableProcessors()); 获得电脑的核心数
BlockingQueue queue =
new LinkedBlockingQueue();
//new ArrayBlockingQueue(10);
ExecutorService executor = new ThreadPoolExecutor(
5, //core
10, //max
120L, //2fenzhong
TimeUnit.SECONDS,
queue);
for(int i = 0 ; i < 20; i++){
executor.execute(new UseThreadPoolExecutor2());
}
Thread.sleep(1000);
System.out.println("queue size:" + queue.size()); //10
Thread.sleep(2000);
}
}
这种无界队列，放入多少任务都不会报错，只会耗尽电脑资源。如果是有界队列的话，放入的任务的数量大于max线程数+队列长度的话就会报错了。
丢弃策略详解
坦白说jdk自带的这四种策略都非常操蛋，原因很简单，丢数据的现象是不容忍的。四种策略概述：
- 抛异常
- 要被丢弃的任务先执行。
- 丢弃最老的请求，尝试再次直接当前任务（后来的插队执行）。
- 丢弃放不进去的任务。
我们对于这种丢弃策略一般都是自定义的，需要实现一个接口：RejectedExecutionHandler
代码实现
import java.net.HttpURLConnection;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
public class MyRejected implements RejectedExecutionHandler{
public MyRejected(){
}
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("自定义处理..");
System.out.println("当前被拒绝任务为：" + r.toString());
}
}
实战经验
一般给前台发消息（httpclient.jar）说拒绝了（但是一般不建议，建立请求，在高峰期不合适）。
记录日志（key信息），缓存到其他地方（本地缓存不下了）(磁盘数据库，非代码级别的缓存)，定时job去处理缓存的任务。然后不停地重试也是种方式（我们做的项目都这么弄的）。