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,"my_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.err.println("当前任务已经被拒绝："+r);
}
});
Task t1 = new Task(1,1);
Task t2 = new Task(2,2);
Task t3 = new Task(3,3);
Task t4 = new Task(4,4);
Task t5 = new Task(5,5);
Task t6 = new Task(6,6);
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
pool.shutdown();
public class Task implements Runnable{
private int id;
private int count;
public Task(int id, int count) {
super();
this.id = id;
this.count = count;
}
@Override
public void run() {
System.err.println("处理线程任务：" + this.id);
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public String toString() {
return "Task [id=" + id + ", count=" + count + "]";
}
}
从代码的运行结果来看
处理线程任务：1
处理线程任务：5
处理线程任务：4
当前任务已经被拒绝：Task [id=6, count=6]
处理线程任务：2
处理线程任务：3
当执行线程t1的时候，直接使用初始化的核心线程执行任务
当执行线程t2的时候，此时线程的数量大于核心线程，则讲t2线程加入有界队列中
当执行线程t3的时候，此时线程的数量大于核心线程 ，则t3线程加入有界队列中
当执行线程t4的时候，此时队列容量已满，此时的线程数量是还没有超过最大线程，则启用一个新的线程执行任务
当执行线程t5的时候，此时队列容量已满，此时的线程数量是还没有超过最大线程，则启用一个新的线程执行任务
当执行线程t6的时候，此时队列容量已满，此时的线程数量超过最大线程，则启用自己的拒绝策略
注意的是，如果把ArrayBlockingQueue 有界队列，换成无界队列LinkedBlockingQueue 则线程池的工作原理是
当线程的数量不超过核心线程的数量，启用线程去执行任务，当线程数量大于核心线程的数量的时候，则直接加入无界队列中等待被执行，此时后的最大线程数量的设置其实是没有作用的
