面试高频知识点：2线程 2.1.5如何自定义实现一个线程池

在Java中，线程池是一种用于管理线程的机制，它可以有效地管理多个线程并且可以重复使用它们，从而减少了线程创建和销毁的开销，提高了线程的利用率。本文将介绍如何自定义实现一个简单的线程池，并提供相应的Java代码示例。

线程池的基本原理

自定义一个简单的线程池需要考虑以下几个关键组件：

1. 任务队列（Task Queue）：用于存储待执行的任务。

2. 线程池管理器（ThreadPool Manager）：负责管理线程池，包括创建、销毁线程等操作。

3. 工作线程（Worker Thread）：实际执行任务的线程。

基本的工作流程如下：

1. 当有任务需要执行时，将任务添加到任务队列中。

2. 线程池管理器不断从任务队列中取出任务，并分配给空闲的工作线程执行。

3. 执行完任务的工作线程将结果返回，并继续等待下一个任务。

4. 当任务队列为空且没有新的任务添加时，线程池管理器会关闭线程池。

实现一个简单的线程池

下面是一个简单的Java实现：

import java.util.LinkedList;
import java.util.List;

public class CustomThreadPool {
    private final int maxThreads;
    private final List threads;
    private final LinkedList taskQueue;

    public CustomThreadPool(int maxThreads) {
        this.maxThreads = maxThreads;
        threads = new LinkedList<>();
        taskQueue = new LinkedList<>();

        for (int i = 0; i < maxThreads; i++) {
            WorkerThread worker = new WorkerThread();
            threads.add(worker);
            worker.start();
        }
    }

    public synchronized void submit(Runnable task) {
        taskQueue.add(task);
        notify();
    }

    public synchronized void shutdown() {
        for (WorkerThread worker : threads) {
            worker.stopThread();
        }
    }

    private class WorkerThread extends Thread {
        private boolean running = true;

        @Override
        public void run() {
            while (running) {
                Runnable task;
                synchronized (CustomThreadPool.this) {
                    while (taskQueue.isEmpty()) {
                        try {
                            CustomThreadPool.this.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    task = taskQueue.poll();
                }
                try {
                    task.run();
                } catch (RuntimeException e) {
                    e.printStackTrace();
                }
            }
        }

        public void stopThread() {
            running = false;
        }
    }
}

// 示例任务
class ExampleTask implements Runnable {
    private final int taskId;

    public ExampleTask(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("Task " + taskId + " is being executed by Thread: " + Thread.currentThread().getName());
    }
}

// 示例用法
class Main {
    public static void main(String[] args) {
        CustomThreadPool threadPool = new CustomThreadPool(3);

        for (int i = 1; i <= 5; i++) {
            Runnable task = new ExampleTask(i);
            threadPool.submit(task);
        }

        threadPool.shutdown();
    }
}

示例解析

• CustomThreadPool 类实现了一个简单的线程池，其中包含了最大线程数、工作线程列表和任务队列等成员变量。

• submit 方法用于向线程池提交任务，并唤醒等待中的工作线程。

• shutdown 方法用于关闭线程池，通过停止所有工作线程的运行来实现。

• WorkerThread 类继承自 Thread，表示线程池中的工作线程，其 run 方法循环执行任务队列中的任务。

• ExampleTask 类是一个示例任务，其中包含了任务的具体执行逻辑。

• 在示例中，通过创建线程池并提交任务，可以看到任务在多个工作线程间被并发执行。