123123123线程池

线程池简易
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicBoolean;

/**

• 简单线程池实现
  */
  public class SimpleThreadPool {
  // 任务队列
  private final BlockingQueue taskQueue;
  // 线程池的工作线程数组
  private final WorkerThread[] threads;
  // 线程池是否停止的标志
  private final AtomicBoolean isStopped = new AtomicBoolean(false);

  /**

  • 构造函数

  • @param numberOfThreads 线程池中线程的数量

  • @param maxNumberOfTasks 队列最大任务数量
    */
    public SimpleThreadPool(int numberOfThreads, int maxNumberOfTasks) {
    taskQueue = new LinkedBlockingQueue<>(maxNumberOfTasks);
    threads = new WorkerThread[numberOfThreads];

    // 初始化并启动所有工作线程
    for (int i = 0; i < numberOfThreads; i++) {
    threads[i] = new WorkerThread();
    threads[i].start();
    }
    }

  /**

  • 提交任务到线程池

  • @param task 需要执行的任务

  • @throws Exception 如果线程池已停止，抛出异常
    */
    public void execute(Runnable task) throws Exception {
    if (this.isStopped.get()) {
    throw new IllegalStateException(“ThreadPool is stopped”);
    }

    this.taskQueue.offer(task);
    }

  /**

  • 停止线程池
  • @throws Exception
    */
    public void stop() throws Exception {
    this.isStopped.set(true);
    for (WorkerThread thread : threads) {
    thread.doStop();
    }
    }

  /**

  • 工作线程类
    */
    private class WorkerThread extends Thread {
    // 线程停止标志
    private AtomicBoolean isStopped = new AtomicBoolean(false);

    @Override
    public void run() {
    // 当线程未被停止时循环执行
    while (!isStopped.get()) {
    try {
    // 从任务队列中取出并执行任务
    Runnable runnable = taskQueue.take();
    runnable.run();
    } catch (Exception e) {
    // 异常处理逻辑（简化处理）
    System.out.println(“Thread interrupted” + e.getMessage());
    }
    }
    }

    /**

    • 停止当前工作线程
      */
      public void doStop() {
      isStopped.set(true);
      // 中断线程
      this.interrupt();
      }
      }
      }