线程池-1：线程池是如何复用线程的？

这段代码实现了一个简单的线程池 SimpleThreadPool。主要包括以下几个关键部分：

1. 构造函数：初始化最大线程数 maxPoolSize、任务队列 taskQueue、当前线程数 currentPoolSize，以及锁 lock 和条件 taskAvailable。

2. submit(Runnable task) 方法：用于提交任务到线程池。如果当前线程数小于最大线程数，会创建并启动一个新的工作线程来执行任务；否则将任务加入任务队列，并通过条件变量通知等待的线程来处理任务。

3. 内部类 Worker：实现了工作线程的逻辑。在运行时，工作线程会循环从任务队列中取出任务并执行，如果队列为空则会等待条件变量通知。该内部类实现了 Runnable 接口，用于执行具体的任务。

4. main 方法：在主方法中创建了一个 SimpleThreadPool 实例，并提交了10个任务给线程池。

需要注意的是，该线程池实现是一个简单的固定大小线程池，当任务数量超过最大线程数时，多余的任务会被放入任务队列中等待执行。代码中并没有为每个任务都创建一个新的线程，在 submit(Runnable task) 方法中，只有当当前线程数小于最大线程数时才会创建新的工作线程来执行任务。如果当前线程数已经达到最大线程数，则会将任务加入任务队列中，等待空闲线程来执行。因此，这个线程池实际上是一个固定大小的线程池，它会复用线程而不是为每个任务都创建一个新的线程。这样可以更有效地利用线程资源，并避免频繁地创建和销毁线程带来的开销。

在实际应用中，可以根据需求进一步扩展和优化线程池的功能，比如增加线程池的关闭方法、异常处理机制等，以确保线程池的稳定性和可靠性。

public class SimpleThreadPool {

    // 最大线程数
    private final int maxPoolSize;
    // 任务队列
    private final Queue<Runnable> taskQueue;
    // 当前线程数
    private int currentPoolSize;
    private final Lock lock = new ReentrantLock();
    private final Condition taskAvailable = lock.newCondition();

    public SimpleThreadPool(int maxPoolSize) {
        this.maxPoolSize = maxPoolSize;
        this.taskQueue = new LinkedList<>();
        this.currentPoolSize = 0;
    }

    public void submit(Runnable task) {
        lock.lock();
        try {
            // 将任务入队列
            if (currentPoolSize < maxPoolSize) {
                // 构建工作线程
                Worker worker = new Worker(task);
                // 启动线程
                worker.thread.start();
                currentPoolSize++;
            } else {
                taskQueue.offer(task);
                // 释放信号通知处理任务
                taskAvailable.signal();
            }
        } finally {
            lock.unlock();
        }
    }

    private class Worker implements Runnable {

        final Thread thread;
        Runnable firstTask;

        Worker(Runnable firstTask) {
            this.firstTask = firstTask;
            this.thread = new Thread(this);
        }

        public void run() {
            Runnable task = this.firstTask;
            this.firstTask = null;
            while (true) {
                lock.lock();
                try {
                    if (task != null || (task = taskQueue.poll()) != null) {
                        try {
                            task.run();
                        } catch (RuntimeException e) {
                            e.printStackTrace();
                        } finally {
                            task = null;
                        }
                    } else {
                        try {
                            taskAvailable.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                } finally {
                    lock.unlock();
                }
            }

        }
    }

    public static void main(String[] args) {
        SimpleThreadPool threadPool = new SimpleThreadPool(5);
        // 提交10个任务给线程池
        for (int i = 0; i < 10; i++) {
            final int task = i;
            threadPool.submit(() -> {
                String threadName = Thread.currentThread().getName();
                System.out.println("Task " + task + " is running on " + threadName);
            });
        }
    }
}

运行结果如图：