关于线程池的详细分析，具体请看这篇帖子：https://www.cnblogs.com/reecelin/p/12334107.html
在开始之前，我们还是再来复习一下线程池的工作流程吧，如下所示：
现在，我们可以根据上面的流程简单写个线程池，如下:
public interface ThreadPool {
/**
* 添加任务
* @param command
* @return
*/
boolean submit(Runnable command);
/**
* 关闭线程池，若有任务，则等待 任务执行完毕
*/
void shutDown();
/**
* 立即关闭线程池
*/
void shutDownNow();
}
public class MyThreadPool implements ThreadPool {
//当前正在工作的线程数
private int currentNum;
//核心线程数
private int corePoolSize;
//最大核心线程数
private static final int MAX_CORE_POOL_SIZE = 3;
//线程池能容纳的最大线程数
private int maxPoolSize;
//最大线程数
private static final int MAX_POOL_SIZE = 6;
//线程池是否启动
private volatile boolean isRunning = true;
//存放添加进线程池的任务队列
private BlockingQueue<Runnable> queue;
private int queueSize;
//任务队列最大长度 这里设置的比较小是为了后面可以使用拒绝策略
private static final int MAX_QUEUE_SIZE = 20;
//存储用于执行添加进线程池中任务的工作线程队列
private List<Worker> workers;
private ReentrantLock lock=new ReentrantLock();
public MyThreadPool() {
this(MAX_CORE_POOL_SIZE, MAX_POOL_SIZE, MAX_QUEUE_SIZE);
}
public MyThreadPool(int corePoolSize, int maxPoolSize, int queueSize) {
this.corePoolSize = corePoolSize > MAX_CORE_POOL_SIZE ? MAX_CORE_POOL_SIZE : corePoolSize;
this.maxPoolSize = maxPoolSize > MAX_POOL_SIZE ? MAX_POOL_SIZE : maxPoolSize;
this.queueSize = queueSize > MAX_QUEUE_SIZE ? MAX_QUEUE_SIZE : queueSize;
queue = new LinkedBlockingQueue<>(this.queueSize);
workers = Collections.synchronizedList(new ArrayList<>(this.maxPoolSize));
intialThreadPool();
}
private void intialThreadPool() {
for (int i = 1; i <= this.corePoolSize; i++) {
Worker worker = new Worker("核心线程-" + i);
workers.add(worker);
worker.start();
currentNum++;
System.out.println(DateUtil.getFormat().format(new Date())+" 核心线程-" + i + " 启动，等待执行任务");
}
}
@Override
public boolean submit(Runnable command) {
if (isRunning) {
//若是核心线程数还没达到最大，则新建核心线程执行任务
if (currentNum < MAX_CORE_POOL_SIZE) {
String threadName = "新建核心线程-" + ++this.corePoolSize;
Worker worker = new Worker(threadName, command);
workers.add(worker);
worker.start();
currentNum++;
return true;
} else if (currentNum >= MAX_CORE_POOL_SIZE && currentNum < MAX_POOL_SIZE) {
//若是队列未满，则直接添加进队列
if (queue.offer(command)) {
return true;
//若是队列已满，则创建非核心线程去执行任务
} else {
String threadName = "非核心线程-" + (currentNum - MAX_CORE_POOL_SIZE);
Worker worker = new Worker(threadName, command);
workers.add(worker);
worker.start();
currentNum++;
return true;
}
//若是线程数已到最大，且队列也满了，则直接执行拒绝策略
} else if (currentNum >= MAX_POOL_SIZE && !queue.offer(command)) {
System.out.println(DateUtil.getFormat().format(new Date())+" 线程池已满负载运行，拒绝了该任务,当前任务队列大小为："+queue.size());
return false;
}
}
return false;
}
@Override
public void shutDown() {
while (!queue.isEmpty()) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
isRunning = false;
for (Worker worker : workers) {
worker.interrupt();
// help gc
worker = null;
}
queue.clear();
}
@Override
public void shutDownNow() {
isRunning = false;
for (Worker worker : workers) {
worker.interrupt();
// help gc
worker = null;
}
queue.clear();
}
private class Worker extends Thread {
private Runnable command;
public Worker(String name) {
super(name);
}
public Worker(String name, Runnable command) {
super(name);
this.command = command;
}
@Override
public void run() {
while (isRunning || !queue.isEmpty()) {
if (command != null) {
command.run();
// help gc
command = null;
} else {
command = queue.poll();
if (command != null) {
command.run();
// help gc
command = null;
}
}
}
}
}
}
public class MyTask implements Runnable {
private int id;
public MyTask(int id) {
this.id = id;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"执行任务："+id+" 完成");
}
}
public class DateUtil {
private static final String pattern="yyyy-MM-dd HH:mm:ss";
private static volatile SimpleDateFormat format;
private DateUtil(){}
public static SimpleDateFormat getFormat(){
if (format==null){
synchronized (DateUtil.class){
if (format==null){
format= new SimpleDateFormat(pattern);
}
}
}
return format;
}
}
public class Test {
public static void main(String[] args) {
MyThreadPool pool=new MyThreadPool(2, 6, 20);
for (int i = 1; i <=40 ; i++) {
pool.submit(new MyTask(i));
}
pool.shutDown();
}
}
运行测试类，控制台输出：
2020-02-22 20:29:56 核心线程-1 启动，等待执行任务
2020-02-22 20:29:56 核心线程-2 启动，等待执行任务
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 线程池已满负载运行，拒绝了该任务,当前任务队列大小为：20
2020-02-22 20:29:56 核心线程-1执行任务：2 完成
2020-02-22 20:29:56 核心线程-1执行任务：3 完成
2020-02-22 20:29:56 核心线程-1执行任务：4 完成
2020-02-22 20:29:56 核心线程-1执行任务：5 完成
2020-02-22 20:29:56 核心线程-1执行任务：6 完成
2020-02-22 20:29:56 核心线程-1执行任务：7 完成
2020-02-22 20:29:56 核心线程-1执行任务：8 完成
2020-02-22 20:29:56 核心线程-1执行任务：9 完成
2020-02-22 20:29:56 核心线程-1执行任务：10 完成
2020-02-22 20:29:56 核心线程-1执行任务：11 完成
2020-02-22 20:29:56 核心线程-1执行任务：12 完成
2020-02-22 20:29:56 核心线程-1执行任务：13 完成
2020-02-22 20:29:56 核心线程-1执行任务：14 完成
2020-02-22 20:29:56 核心线程-1执行任务：15 完成
2020-02-22 20:29:56 核心线程-1执行任务：16 完成
2020-02-22 20:29:56 核心线程-1执行任务：17 完成
2020-02-22 20:29:56 核心线程-1执行任务：18 完成
2020-02-22 20:29:56 核心线程-1执行任务：19 完成
2020-02-22 20:29:56 核心线程-1执行任务：20 完成
2020-02-22 20:29:56 核心线程-1执行任务：21 完成
2020-02-22 20:29:56 新建核心线程-3执行任务：1 完成
2020-02-22 20:29:56 非核心线程-1执行任务：23 完成
2020-02-22 20:29:56 非核心线程-0执行任务：22 完成
2020-02-22 20:29:56 非核心线程-2执行任务：24 完成
这个只是简单的线程池，许多功能都没有完善，但对于了解线程池的执行流程有一定帮助。后面会继续完善这个demo，使其更加完整。