1、使用有界队列构建线程池
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("执行任务:taskId = " + this.taskId);
Thread.sleep(4*1000);
System.out.println("任务"+this.taskId+",执行完成");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public String toString(){
return Integer.toString(this.taskId);
}
}
/**
* 拒绝策略
* 记录日志,返回 http请求数据给客户端
*/
public class MyRejected implements RejectedExecutionHandler{
public MyRejected(){
}
/**
* @param r 当前任务对象
* @param executor 当前线程池对象
*/
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("队列已满执行自定义拒绝策略:当前被拒绝任务为:" + r.toString());
}
}
package com.liaoxiang.multithreading3.middle.custom_thread_pool;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* custom_thread_pool:使用有界队列
* 在使用有界队列时,当有新的任务需要执行的时候:
* 若线程池实际线程数小于corePoolSize,则优先创建线程,
* 若大于corePoolSize,则会将任务加入队列,
* 若队列已满,则在总线程数不大于maximumPoolSize的前提下,创建新的线程,
* 若线程数大于maximumPoolSize,则执行拒绝策略,或其他自定义方式。
*/
public class CustomThreadPoolExecutor1 {
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(
1, //corePoolSize
2, //maximumPoolSize
60, //当线程池中的线程数量大于 corePoolSize 的时候,如果这时没有新的任务提交
//核心线程外的线程不会立即销毁,而是会等待,直到等待的时间超过了 keepAliveTime才会被回收销毁;
TimeUnit.SECONDS, //时间单位为s
new ArrayBlockingQueue<>(3) , //使用阻塞有界队列存放等待的线程
new MyRejected() //自定义拒绝策略,线程数大于maximumPoolSize时执行
//new DiscardOldestPolicy() //丢弃最老的,234被加到队列中,2被丢弃,执行第6个任务
);
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);
//coreSize=1,则mt2线程将会被放到队列中
pool.execute(mt2);
pool.execute(mt3);
pool.execute(mt4);
//当同时执行5个线程时,由于234被放到队列中,当第5个任务进来时,队列已经满了,而线程池的MaxSize=2,则会创建新的线程执行第5个任务
pool.execute(mt5);
//当执行6个任务的时候,234同样进队列,创建第2个线程执行第5个任务,因为MaxSize=2,不能再创建新的线程,因此会被拒绝
pool.execute(mt6);
//线程任务执行完之后,停止线程
pool.shutdown();
}
}
执行流程:
2、使用无界队列创建线程池
package com.liaoxiang.multithreading3.middle.custom_thread_pool;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* custom_thread_pool:使用无界队列
* 与有界队列相比,除非系统资源耗尽,否则无界的任务队列不存在任务如队列失败的情况。
* 当有新的任务到来时,系统的线程数小于corePoolSize时,则新建线程执行任务。
* 若后续仍有新的任务加入,而没有空闲的线程资源,则任务直接进入队列等待。
* 若任务创建和处理的速度差异很大,无界队列会保持快速增长,直到耗尽系统内存
*/
public class CustomThreadPoolExecutor2 implements Runnable {
private static AtomicInteger count = new AtomicInteger(0);
/**
* 执行线程任务,耗时2s
*/
@Override
public void run() {
try {
int temp = count.incrementAndGet();
System.out.println("执行任务" + temp);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* 使用无界队列时,开始执行corePoolSize个任务,其余的加入队列,每次执行完了之后,从队列中取出5个再次运行
* @param args
* @throws Exception
*/
public static void main(String[] args) {
ExecutorService executor = new ThreadPoolExecutor(
2, //core
4, //max
120L, //2分钟
TimeUnit.SECONDS, //时间单位为分钟
new LinkedBlockingQueue<>()); //使用无界队列
for (int i = 0; i < 5; i++) {
executor.execute(new CustomThreadPoolExecutor2());
}
executor.shutdown();
}
}
//开始第一批任务执行
执行任务1
执行任务2
//开始第二批任务执行
执行任务3
执行任务4
//开始第三批任务执行
执行任务5
此时最大线程数设置为2,和4,效果是一样的。猜测可能是因为使用无界队列,当线程数达到核心线程数后,剩余的任务都加到了队列中,所以不再创建新的线程,设置最大线程数无效