Java手写线程池的实现方法

下面我将详细讲解Java手写线程池的实现方法的完整攻略。在此过程中，我将会介绍线程池的概念和原理，并提供两个示例来帮助理解。

一、线程池的概念

线程池是一种多线程处理的方式，它可以让线程进行复用，避免频繁创建和销毁线程带来的开销。线程池一般由三部分组成：任务队列、工作线程和线程管理器。

二、线程池的实现方法

1. 创建任务类

任务类用于封装具体的任务逻辑，需要实现Runnable接口，并重写run()方法。

public class Task implements Runnable {
    private String name;
    public Task(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println("执行任务 " + name + "，线程名为：" + Thread.currentThread().getName());
    }
}

2. 创建线程池类

线程池类需要包含以下属性：

• workQueue，任务队列，用于存放待处理的任务；
• threads，工作线程集合，用于存放工作线程；
• isShutdown，是否关闭线程池；
• threadFactory，线程工厂，用于创建线程；
• maxThreadCount，线程池允许的最大工作线程数。

public class ThreadPool {
    private final BlockingQueue<Runnable> workQueue;
    private final List<WorkerThread> threads;
    private volatile boolean isShutdown;
    private ThreadFactory threadFactory;
    private int maxThreadCount;

    public ThreadPool(int maxThreadCount, ThreadFactory threadFactory) {
        this.maxThreadCount = maxThreadCount;
        this.threadFactory = threadFactory;
        workQueue = new LinkedBlockingQueue<>();
        threads = new ArrayList<>();
        isShutdown = false;
    }
    // ...
}

3. 创建工作线程类

工作线程类需要实现Runnable接口，并重写run()方法。

private class WorkerThread implements Runnable {
    private Thread thread;
    public WorkerThread() {
        thread = threadFactory.newThread(this);
    }
    @Override
    public void run() {
        while (!isShutdown) {
            try {
                Runnable task = workQueue.take();
                task.run();
            } catch (InterruptedException e) {
                System.out.println("线程被中断:" + e.getMessage());
            }
        }
    }
}

4. 开启线程池

在ThreadPool类中，实现开启线程池的方法start()，其中需要初始化工作线程并加入线程池。

public synchronized void start() {
    for (int i = 0; i < maxThreadCount; i++) {
        WorkerThread worker = new WorkerThread();
        threads.add(worker);
        worker.thread.start();
    }
}

5. 关闭线程池

在ThreadPool类中，实现关闭线程池的方法shutdown()，其中需要将任务队列中的任务全部取出并执行，然后才能关闭工作线程。

public synchronized void shutdown() {
    isShutdown = true;
    while (!workQueue.isEmpty()) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            System.out.println("线程被中断:" + e.getMessage());
        }
    }
    for (WorkerThread worker : threads) {
        worker.thread.interrupt();
    }
}

三、示例说明

示例一

ThreadFactory threadFactory = Executors.defaultThreadFactory();
ThreadPool threadPool = new ThreadPool(4, threadFactory);

for (int i = 1; i <= 10; i++) {
    threadPool.submit(new Task("任务 " + i));
}

threadPool.start();
threadPool.shutdown();

这个示例中，我们使用默认的线程工厂Executors.defaultThreadFactory()创建线程池，并将最大线程数限制为4。然后，我们创建10个任务对象，并将它们提交到线程池中。最后，我们开启线程池并等待所有任务执行完毕，然后关闭线程池。

示例二

ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("worker-thread-%d").build();
ThreadPool threadPool = new ThreadPool(5, threadFactory);

for (int i = 1; i <= 15; i++) {
    threadPool.submit(new Task("任务 " + i));
}

threadPool.start();
threadPool.shutdown();

这个示例中，我们使用ThreadFactoryBuilder来创建线程工厂，并将工作线程的名称格式化为"worker-thread-%d"。然后，我们创建15个任务对象，并将它们提交到线程池中。最后，我们开启线程池并等待任务执行完毕，然后关闭线程池。