Java 스레드 풀 구현 원리의 소스 코드 분석

스레드 풀의 기원

배경: 컴퓨터 하드웨어가 업그레이드되면서 우리 소프트웨어는 여러 스레드에서 작업을 수행할 수 있게 되었습니다. 멀티 스레드 프로그래밍을 할 때 스레드를 생성해야 하는데, 프로그램 동시성이 매우 높으면 많은 수의 스레드가 생성되며, 각 스레드는 짧은 작업을 수행한 다음 자주 종료됩니다. 스레드를 생성하고 삭제하려면 추가 소비가 필요하기 때문에 시스템 성능이 크게 감소하고 서버 오버헤드가 증가합니다.

이때 이 결함을 최적화하기 위해 풀링 기술을 사용할 수 있고, 스레드 풀이 탄생했습니다.

풀링 기술의 본질은 동시성이 높은 시나리오에서 리소스 재사용을 달성하고 리소스 생성 및 파괴 오버헤드를 줄이는 것입니다. 동시성 수가 적으면 뚜렷한 이점이 없습니다(리소스는 항상 시스템 메모리를 차지하며 그럴 가능성이 없습니다). 사용된).

풀링 기술 소개: 풀링 기술은 언제 사용되나요? 풀링(Pooling) 기술은 프로그램의 동시성이 높을 때 프로그램을 획기적으로 최적화하고, 시스템 내에서 잦은 연결 생성과 소멸 등 추가적인 오버헤드를 줄일 수 있는 프로그래밍 기법이다. 우리가 자주 접하게 되는 풀링 기술에는 데이터베이스 연결 풀, 스레드 풀, 개체 풀 등이 포함됩니다. 풀링 기술의 특징은 일부 고비용 리소스를 특정 풀(메모리)에 유지하고 최소 연결 수, 최대 연결 수, 차단 대기열, 오버플로 규칙 및 기타 구성을 지정하여 통합 관리를 용이하게 하는 것입니다. 정상적인 상황에서는 모니터링 및 강제 재활용과 같은 일부 지원 기능도 함께 제공됩니다.

풀링 기술은 리소스 사용 기술입니다. 일반적인 사용 시나리오는 다음과 같습니다.

• 리소스 획득 비용이 높은 경우

• 리소스 요청 빈도가 높고 사용되는 총 리소스 수가 적은 경우

• 처리 시간 지연과 관련된 성능 문제가 발생한 경우

풀링 기술 리소스 분류:

• 스레드, 프로세스, 메모리 할당 등 시스템에서 호출하는 시스템 리소스

• 데이터베이스 연결, 소켓 연결 등 네트워크 통신을 위한 원격 리소스

스레드 풀의 정의 및 사용

스레드 풀은 스레드를 생성하고 스레드를 파괴하는 추가 오버헤드를 피하기 위해 탄생했기 때문에 After를 정의하고 생성합니다. 스레드 풀을 사용하려면 스레드를 직접 생성할 필요가 없지만 스레드 풀 호출을 사용하여 작업을 수행합니다. 스레드 풀을 정의하고 생성하는 방법을 살펴보겠습니다.

옵션 1: 실행기(이해를 돕기 위해 옵션 2를 권장함)

스레드 풀을 생성하려면 Executors를 사용할 수 있습니다. 이 Executors는 스레드 풀 생성을 위한 일련의 팩토리 메서드를 제공하며, 반환된 스레드 풀은 모두 구현합니다.

ExecutorService

인터페이스. ExecutorService 인터페이스는 Executor 인터페이스의 하위 클래스 인터페이스이며 더 널리 사용됩니다. 스레드 풀 수명 주기 관리 방법을 제공하고

Future 개체

를 반환합니다. ExecutorService，通过ExecutorService执行异步任务（实现Runnable接口）

Executors 可以创建一下几种类型的线程池：

• newCachedThreadPool 创建一个可缓存线程池，如果线程池线程数量过剩，会在60秒后回收掉多余线程资源，当任务书增加，线程不够用，则会新建线程。

• newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

• newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

• newSingleThreadExecutor 创建一个单线程的线程池，只使用唯一的线程来执行任务，可以保证任务按照提交顺序来完成。

方案二：ThreadPoolExecutor

在阿里巴巴开发规范中，规定线程池不允许通过Executors创建，而是通过ThreadPoolExecutor创建。

好处：让写的同学可以更加明确线程池的运行规则，规避资源耗尽的风险。

ThreadPoolExecutor的七大参数：

(1)corePoolSize 核心线程数量，核心线程会一直保留，不会被销毁。

(2)maximumPoolSize 最大线程数，当核心线程不能满足任务需要时，系统就会创建新的线程来执行任务。

(3)keepAliveTime 存活时间，核心线程之外的线程空闲多长时间就会被销毁。

(4)timeUnit 代表线程存活的时间单位。

(5)BlockingQueue

즉, Executor를 통해 스레드 풀을 만들고, ExecutorService를 가져오고, ExecutorService를 통해 비동기 작업(Runnable 인터페이스 구현)을 실행합니다.

• Executor는 여러 가지를 생성할 수 있습니다. 유형 스레드 풀:

• newCachedThreadPool 은 캐시 가능한 스레드 풀을 생성합니다. 스레드 풀에 스레드가 너무 많으면 작업 책이 증가하면 초과 스레드 리소스가 재활용됩니다. , 스레드가 충분하지 않습니다. 새 스레드가 생성됩니다.

  🎜🎜newFixedThreadPool은 최대 동시 스레드 수를 제어할 수 있는 고정 길이 스레드 풀을 생성합니다. 🎜🎜🎜🎜newScheduledThreadPool 예약 및 주기적인 작업 실행을 지원하기 위해 고정 길이 스레드 풀을 생성합니다. 🎜🎜🎜🎜newSingleThreadExecutor 단일 스레드 스레드 풀을 생성하고 작업 실행에 유일한 스레드만 사용하여 작업이 제출된 순서대로 완료되도록 합니다. 🎜🎜🎜🎜옵션 2: ThreadPoolExecutor🎜🎜Alibaba 개발 사양에는 스레드 풀이 Executor를 통해 생성되는 것이 허용되지 않고 ThreadPoolExecutor를 통해 생성되도록 규정되어 있습니다. 🎜🎜혜택: 글을 쓰는 학생들은 스레드 풀의 운영 규칙을 더 명확하게 알고 리소스 고갈 위험을 피할 수 있습니다. 🎜🎜🎜ThreadPoolExecutor의 7개 매개변수: 🎜🎜🎜(1)corePoolSize 코어 스레드 수는 항상 유지되며 삭제되지 않습니다. 🎜🎜(2)maximumPoolSize 코어 스레드가 작업 요구 사항을 충족할 수 없는 경우 시스템은 작업을 실행하기 위해 새 스레드를 생성합니다. 🎜🎜(3)keepAliveTime 생존 시간, 코어 스레드 이외의 스레드가 유휴 상태인 기간이 삭제됩니다. 🎜🎜(4)timeUnit 은 스레드 생존을 위한 시간 단위를 나타냅니다. 🎜🎜(5)BlockingQueue Blocking queue🎜🎜🎜🎜실행 중인 작업이 최대 스레드 수를 초과하는 경우 스레드 풀에 여유 리소스가 있으면 대기열에 저장할 수 있습니다. 작업을 대기열에서 꺼낼 수 있습니다. 실행을 계속합니다. 🎜🎜🎜🎜🎜큐 유형은 다음과 같습니다. 🎜LinkedBlockingQueue ArrayBlockingQueue 동기 대기열 TransferQueue. 🎜

(6)threadFactory 스레드 팩토리는 스레드를 생성하는 데 사용됩니다. 예를 들어 스레드 그룹 이름을 정의할 수 있으며 이는 jstack 문제를 해결할 때 매우 유용합니다. threadFactory 线程工厂，用来创建线程的，可以自定义线程，比如我们可以定义线程组名称，在jstack问题排查时，非常有帮助。

(7)rejectedExecutionHandler 拒绝策略,

当所有线程（最大线程数）都在忙，并且任务队列处于满任务的状态，则会执行拒绝策略。

JDK为我们提供了四种拒绝策略，我们必须都得熟悉

• AbortPolicy: 丢弃任务，并抛出异常RejectedExecutionException。 默认

• DiscardPolicy: 丢弃最新的任务，不抛异常。

• DiscardOldestPolicy: 扔掉排队时间最久的任务，也就是最旧的任务。

• CallerRuns: 由调用者（提交异步任务的线程）处理任务。

线程池的实现原理

想要实现一个线程池我们就需要关心ThreadPoolExecutor类，因为Executors创建线程池也是通过new ThreadPoolExecutor对象。

看一下ThreadPoolExecutor的类继承关系，可以看出为什么通过Executors创建的线程池返回结果是ExecutorService，因为ThreadPoolExecutor是ExecutorService接口的实现类，而Executors创建线程池本质也是创建的ThreadPoolExecutor 对象。

下面我们一起看一下ThreadPoolExecutor的源码，首先是ThreadPoolExecutor内定义的变量，常量：

    // 复合类型变量 是一个原子整数  控制状态（运行状态|线程池活跃线程数量）
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); 
    private static final int COUNT_BITS = Integer.SIZE - 3; // 低29位 
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1; // 容量
    // 运行状态存储在高位3位
    private static final int RUNNING    = -1 << COUNT_BITS;  // 接受新任务，并处理队列任务
    private static final int SHUTDOWN   =  0 << COUNT_BITS;  // 不接受新任务，但会处理队列任务
    private static final int STOP       =  1 << COUNT_BITS;  // 不接受新任务，不会处理队列任务，中断正在处理的任务
    private static final int TIDYING    =  2 << COUNT_BITS;  // 所有的任务已结束，活跃线程为0，线程过渡到TIDYING状       态，将会执行terminated()钩子方法
    private static final int TERMINATED =  3 << COUNT_BITS;  // terminated()方法已经完成
    // 设置 ctl 参数方法
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    private static int ctlOf(int rs, int wc) { return rs | wc; }
    /**
     * 阻塞队列
     */
    private final BlockingQueue<Runnable> workQueue;
    /**
     * Lock 锁.
     */
    private final ReentrantLock mainLock = new ReentrantLock();
    /**
     * 工人们
     */
    private final HashSet<Worker> workers = new HashSet<Worker>();
    /**
     * 等待条件支持等待终止
     */
    private final Condition termination = mainLock.newCondition();
    /**
     * 最大的池大小.
     */
    private int largestPoolSize;
    /**
     * 完成任务数
     */
    private long completedTaskCount;
    /**
     * 线程工厂
     */
    private volatile ThreadFactory threadFactory;
    /**
     * 拒绝策略
     */
    private volatile RejectedExecutionHandler handler;
    /**
     * 存活时间
     */
    private volatile long keepAliveTime;
    /**
     * 允许核心线程数
     */
    private volatile boolean allowCoreThreadTimeOut;
    /**
     * 核心线程数
     */
    private volatile int corePoolSize;
    /**
     * 最大线程数
     */
    private volatile int maximumPoolSize;
    /**
     * 默认拒绝策略
     */
    private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();
    /**
     * shutdown and shutdownNow权限
     */
    private static final RuntimePermission shutdownPerm =
        new RuntimePermission("modifyThread");

构造器,,支持最少五种参数，最大七中参数的四种构造器：

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

工人，线程池中执行任务的，线程池就是通过这些工人进行工作的，有核心员工（核心线程）和临时工（人手不够的时候，临时创建的，如果空闲时间厂，就会被裁员），

    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        private static final long serialVersionUID = 6138294804551838833L;
        // 工人的本质就是个线程
        final Thread thread;
        // 第一件工作任务
        Runnable firstTask;
      volatile long completedTasks;
        /**
         * 构造器
         */
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }
        /** 工作  */
        public void run() {
            runWorker(this);
        }
        protected boolean isHeldExclusively() {
            return getState() != 0;
        }
        protected boolean tryAcquire(int unused) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        protected boolean tryRelease(int unused) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
        public void lock()        { acquire(1); }
        public boolean tryLock()  { return tryAcquire(1); }
        public void unlock()      { release(1); }
        public boolean isLocked() { return isHeldExclusively(); }
        void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

核心方法，通过线程池执行任务（这也是线程池的运行原理）：

• 检验任务

• 获取当前线程池状态

• 判断上班工人数量是否小于核心员工数

• 如果小于则招人，安排工作

• 不小于则判断等候区任务是否排满

• 如果没有排满则任务排入等候区

• 如果排满，看是否允许招人，允许招人则招临时工

• 如果都不行，该线程池无法接收新任务，开始按老板约定的拒绝策略，执行拒绝策略

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

submit（）方法是其抽象父类定义的，这里我们就可以明显看到submit与execute的区别，通过submit调用，我们会创建RunnableFuture

(7)rejectedExecutionHandler 거부 정책,

모든 스레드(최대 스레드 수)가 사용 중이고 작업 대기열이 작업으로 가득 차면 거부 정책이 실행됩니다.

JDK는 네 가지 거부 전략을 제공합니다. 우리 모두는

• AbortPolicy에 익숙해야 합니다. 작업을 중단하고 RejectedExecutionException 예외를 발생시킵니다. Default

  🎜🎜
• 🎜DiscardPolicy: 예외를 발생시키지 않고 최신 작업을 삭제합니다. 🎜🎜
• 🎜DiscardOldestPolicy: 대기열 시간이 가장 긴 작업, 즉 가장 오래된 작업을 삭제합니다. 🎜🎜
• 🎜CallerRuns: 작업은 호출자(비동기 작업을 제출한 스레드)에 의해 처리됩니다. 🎜🎜🎜

  스레드 풀 구현 원리

  🎜스레드 풀을 구현하려면 ThreadPoolExecutor 클래스에 주의해야 합니다. 왜냐하면 Executor도 새로운 ThreadPoolExecutor 객체를 통해 스레드 풀을 생성하기 때문입니다. 🎜🎜ThreadPoolExecutor의 클래스 상속 관계를 보면 ThreadPoolExecutor가 ExecutorService 인터페이스의 구현 클래스이기 때문에 Executors를 통해 생성된 스레드 풀이 ExecutorService 결과를 반환하는 이유를 알 수 있습니다. 및 Executors 스레드 풀 생성의 핵심은 ThreadPoolExecutor 개체를 생성하는 것이기도 합니다. 🎜🎜🎜🎜함께해요 ThreadPoolExecutor의 소스 코드를 살펴보세요. 첫 번째는 ThreadPoolExecutor에 정의된 변수와 상수입니다. 🎜

  public abstract class AbstractExecutorService implements ExecutorService {
      public Future<?> submit(Runnable task) {
          if (task == null) throw new NullPointerException();
          RunnableFuture<Void> ftask = newTaskFor(task, null);
          execute(ftask);
          return ftask;
      }
      public <T> Future<T> submit(Runnable task, T result) {
          if (task == null) throw new NullPointerException();
          RunnableFuture<T> ftask = newTaskFor(task, result);
          execute(ftask);
          return ftask;
      }
      public <T> Future<T> submit(Callable<T> task) {
          if (task == null) throw new NullPointerException();
          RunnableFuture<T> ftask = newTaskFor(task);
          execute(ftask);
          return ftask;
      }
      ...
  }

  🎜🎜 생성자는 최소 5개 매개변수와 최대 1개 매개변수를 지원합니다. 7개의 매개변수 중 4개 중 생성자: 🎜🎜

      private boolean addWorker(Runnable firstTask, boolean core) {
          retry:
          for (;;) {
              int c = ctl.get();
              int rs = runStateOf(c);
              // 判断状态，及任务列表
              if (rs >= SHUTDOWN &&
                  ! (rs == SHUTDOWN &&
                     firstTask == null &&
                     ! workQueue.isEmpty()))
                  return false;
              for (;;) {
                  int wc = workerCountOf(c);
                  if (wc >= CAPACITY ||
                      wc >= (core ? corePoolSize : maximumPoolSize))
                      return false;
                  if (compareAndIncrementWorkerCount(c))
                      break retry;
                  c = ctl.get();  // Re-read ctl
                  if (runStateOf(c) != rs)
                      continue retry;
                  // else CAS failed due to workerCount change; retry inner loop
              }
          }
          boolean workerStarted = false;
          boolean workerAdded = false;
          Worker w = null;
          try {
              w = new Worker(firstTask);
              final Thread t = w.thread;
              if (t != null) {
                  final ReentrantLock mainLock = this.mainLock;
                  mainLock.lock();
                  try {
                      int rs = runStateOf(ctl.get());
                      if (rs < SHUTDOWN ||
                          (rs == SHUTDOWN && firstTask == null)) {
                          if (t.isAlive()) // precheck that t is startable
                              throw new IllegalThreadStateException();
                          workers.add(w);
                          int s = workers.size();
                          if (s > largestPoolSize)
                              largestPoolSize = s;
                          workerAdded = true;
                      }
                  } finally {
                      mainLock.unlock();
                  }
                  if (workerAdded) {
                      t.start();
                      workerStarted = true;
                  }
              }
          } finally {
              if (! workerStarted)
                  addWorkerFailed(w);
          }
          return workerStarted;
      }

  🎜 스레드 풀에서 작업을 수행하는 작업자입니다. 스레드 풀은 이러한 작업자를 통해 작동합니다. 여유 시간 공장이 있으면 해고됩니다. 🎜

      private Runnable getTask() {
          boolean timedOut = false; // Did the last poll() time out?
          for (;;) {
              int c = ctl.get();
              int rs = runStateOf(c);
              // Check if queue empty only if necessary.
              if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                  decrementWorkerCount();
                  return null;
              }
              int wc = workerCountOf(c);
              // Are workers subject to culling?
              boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
              if ((wc > maximumPoolSize || (timed && timedOut))
                  && (wc > 1 || workQueue.isEmpty())) {
                  if (compareAndDecrementWorkerCount(c))
                      return null;
                  continue;
              }
              try {
                  Runnable r = timed ?
                      workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                      workQueue.take();
                  if (r != null)
                      return r;
                  timedOut = true;
              } catch (InterruptedException retry) {
                  timedOut = false;
              }
          }
      }

  🎜🎜핵심 메소드는 스레드 풀을 통해 작업을 실행합니다(이것은 스레드 풀의 작동 원리이기도 합니다): 🎜🎜
  • 🎜검사 작업 🎜🎜
  • 🎜현재 스레드 풀 상태 가져오기🎜🎜
  • 🎜근무 작업자 수가 핵심 직원 수보다 적은지 여부 판단🎜🎜
  • 🎜적으면 인력을 모집해서 업무를 주선한다🎜🎜
  • 🎜적지 않다면 대기실의 업무가 꽉 찼는지 판단🎜🎜
  • 🎜그렇지 않으면 업무 배치 대기실에서🎜🎜
  • 🎜작업이 꽉 차면 채용이 허용되는지 확인하세요. 채용이 허용되면 임시 직원을 고용합니다🎜🎜
  • 🎜모든 작업이 실패하면 스레드 풀에서 새 작업을 받을 수 없습니다. 그리고 상사가 동의한 거부 전략에 따라 거부 전략을 실행하기 시작합니다🎜🎜🎜

       final void runWorker(Worker w) {
            Thread wt = Thread.currentThread();
            Runnable task = w.firstTask;
            w.firstTask = null;
            w.unlock(); // allow interrupts
            boolean completedAbruptly = true;
            try {
                while (task != null || (task = getTask()) != null) {
                    w.lock();
                    // If pool is stopping, ensure thread is interrupted;
                    // if not, ensure thread is not interrupted.  This
                    // requires a recheck in second case to deal with
                    // shutdownNow race while clearing interrupt
                    if ((runStateAtLeast(ctl.get(), STOP) ||
                         (Thread.interrupted() &&
                          runStateAtLeast(ctl.get(), STOP))) &&
                        !wt.isInterrupted())
                        wt.interrupt();
                    try {
                        beforeExecute(wt, task);
                        Throwable thrown = null;
                        try {
                            task.run();
                        } catch (RuntimeException x) {
                            thrown = x; throw x;
                        } catch (Error x) {
                            thrown = x; throw x;
                        } catch (Throwable x) {
                            thrown = x; throw new Error(x);
                        } finally {
                            afterExecute(task, thrown);
                        }
                    } finally {
                        task = null;
                        w.completedTasks++;
                        w.unlock();
                    }
                }
                completedAbruptly = false;
            } finally {
                processWorkerExit(w, completedAbruptly);
            }
        }

    🎜 submit() 메소드는 추상 상위 클래스에 의해 정의됩니다. 여기서 우리는 차이점을 명확하게 볼 수 있습니다. submit 및 실행을 호출하여 RunnableFuture를 생성하고 Future를 반환합니다. 여기서는 submit 메서드에 반환 값 유형을 알릴 수 있으며 일반 Constraint 반환 값을 전달합니다. 🎜rrreee🎜🎜addWorker()는 사람을 모집하는 방법입니다. 🎜🎜rrreee🎜🎜작업을 가져오는 방법: 🎜🎜rrreee🎜🎜직원이 일하고, 작업을 할당하고, 작업을 실행할 수 있는 방법: 🎜🎜rrreee

위 내용은 Java 스레드 풀 구현 원리의 소스 코드 분석의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!