当前位置：首页 > article >正文

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

article 2024/11/17 11:27:48

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

线程池的基本原理

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

任务队列（Task Queue）：用于存储待执行的任务。
线程池管理器（ThreadPool Manager）：负责管理线程池，包括创建、销毁线程等操作。
工作线程（Worker Thread）：实际执行任务的线程。

基本的工作流程如下：

当有任务需要执行时，将任务添加到任务队列中。
线程池管理器不断从任务队列中取出任务，并分配给空闲的工作线程执行。
执行完任务的工作线程将结果返回，并继续等待下一个任务。
当任务队列为空且没有新的任务添加时，线程池管理器会关闭线程池。

实现一个简单的线程池

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

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

public class CustomThreadPool {
    private final int maxThreads;
    private final List<WorkerThread> threads;
    private final LinkedList<Runnable> 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();
    }
}