手写线程池

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 * @Date 2022/6/15
 * 线程池核心：复用机制
 * 1.提前创建固定线程一直运行状态--死循环实现
 * 2.提交的线程任务缓存到一个并发队列中，交给正在运行的线程执行
 * 3.正在运行的线程从队列中获取该任务执行
 */


public class MyExecutors {

    // 正在运行的工作线程
    private List<Thread> workThreadList;
    // 缓存任务线程
    private LinkedBlockingQueue<Runnable> runnableQueue;

    public MyExecutors(int maxThreadCount, int queueSize) {
        // 限制队列容量缓存
        runnableQueue = new LinkedBlockingQueue<>(queueSize);
        // 1.提前创建固定线程一直运行状态--死循环实现
        workThreadList = new ArrayList<>(maxThreadCount);
        for(int i = 0; i < maxThreadCount; i++) {
            WorkThread workThread = new WorkThread();
            workThread.start();
        }
    }

    class WorkThread extends Thread {
        @Override
        public void run() {
            while (true) {
                Runnable poll = runnableQueue.poll();
                if(poll != null) {
                    poll.run();
                }
            }
        }
    }

    public boolean execute(Runnable runnable) {
        return runnableQueue.offer(runnable);
    }


    public static void main(String[] args) {
        MyExecutors myExecutors = new MyExecutors(3, 10);
        for (int i = 0; i < 10; i++) {
            final int fi = i;
            myExecutors.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(fi+"====="+Thread.currentThread().getName());
                }
            });
        }
    }
}

输出：
0=Thread-4
1=Thread-2
2=Thread-4
3=Thread-2
4=Thread-2
7=Thread-2
6=Thread-4
8=Thread-2
9=Thread-4
5=Thread-3