模拟手写Java线程池（简约版）

线程池核心点：复用机制 

1. 提前创建好固定的线程一直在运行状态 ---- 死循环实现

2. 提交的线程任务缓存到一个并发队列集合中，交给我们正在运行的线程执行

3. 正在运行的线程就从队列中获取该任务执行

 创建线程类继承Thread

import java.util.concurrent.BlockingQueue;

public class MyThread extends Thread{

    private BlockingQueue<Runnable> blockingQueue;
    
    public MyThread(BlockingQueue<Runnable> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    @Override
    public void run() {
        while (MyExecutors.isStop == false || blockingQueue.size()>0){
            //从任务队列中取出任务执行
            Runnable poll = blockingQueue.poll();
            if(poll!=null){
                poll.run();
            }
        }
    }
}

创建线程池

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

public class MyExecutors {
    //任务队列
    private BlockingQueue<Runnable> blockingQueue;
    //表示线程池是否关闭 true关闭 false不关闭
    public static boolean isStop = false;

    /**
     * @param maxThreads 最大线程数
     * @param maxQueueSize 任务队列长度
     */
    public MyExecutors(Integer maxThreads,Integer maxQueueSize) {
        this.blockingQueue = new LinkedBlockingDeque<>(maxQueueSize);
        for (int i = 0; i < maxThreads; i++) {
            new MyThread(blockingQueue).start();
        }
    }

    public boolean execute(Runnable runnable){
        //将任务放入工作队列
        return blockingQueue.offer(runnable);
    }
}

测试类验证

public class Test3 {

    public static void main(String[] args) {
        MyExecutors myExecutors = new MyExecutors(2, 10);
        for (int i = 0; i < 10; i++) {
            myExecutors.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //关闭线程池
        MyExecutors.isStop = true;

    }
}

测试类中，我们创建的线程数量为2，任务队列长度为10，for循环中创建10个任务放入任务队列，打印结果如下：

 本质思想：创建的线程，不会立马停止或者销毁而是一直实现复用，正在运行的线程从并发队列中获取任务执行，从而实现多线程复用问题。