线程池工作机制

2022-02-24  本文已影响0人  w达不溜w
1、线程池的好处
2、线程池的创建的各个参数含义

ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务

/**
 * Creates a new {@code ThreadPoolExecutor} with the given initial
 * parameters.
 *
 * @param corePoolSize the number of threads to keep in the pool, even
 *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
 * @param maximumPoolSize the maximum number of threads to allow in the
 *        pool
 * @param keepAliveTime when the number of threads is greater than
 *        the core, this is the maximum time that excess idle threads
 *        will wait for new tasks before terminating.
 * @param unit the time unit for the {@code keepAliveTime} argument
 * @param workQueue the queue to use for holding tasks before they are
 *        executed.  This queue will hold only the {@code Runnable}
 *        tasks submitted by the {@code execute} method.
 * @param threadFactory the factory to use when the executor
 *        creates a new thread
 * @param handler the handler to use when execution is blocked
 *        because the thread bounds and queue capacities are reached
 * @throws IllegalArgumentException if one of the following holds:<br>
 *         {@code corePoolSize < 0}<br>
 *         {@code keepAliveTime < 0}<br>
 *         {@code maximumPoolSize <= 0}<br>
 *         {@code maximumPoolSize < corePoolSize}
 * @throws NullPointerException if {@code workQueue}
 *         or {@code threadFactory} or {@code handler} is null
 */
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

corePoolSize 核心线程数

maximumPoolSize 最大线程数

线程池中允许的最大线程数。

keepAliveTime 线程空闲时的存活时间

当线程没有执行任务时，继续存活的时间。当线程池中的线程数量大于核心线程数时，即时没有新任务提交，核心线程外的线程也不会立即销毁，而是等待keepAliveTime才会销毁。

unit 线程空闲时的存活时间单位

workQueue 阻塞队列

阻塞队列：1）支持阻塞的插入方法：当队列满时，队列会阻塞插入元素的线程，直到队列不满；2）支持阻塞的移除方法：在队列为空时，获取元素的线程会等待队列变为非空

生产者和消费者模式能够解决并发问题，通过平衡生产线程和消费线程的工作能力来提高程序整体处理数据的速度。通过阻塞队列来进行通信，生产者生产完数据不用等待消费者处理，直接扔给阻塞队列，消费者也直接从阻塞队列中取数据，既能够解耦，又平衡两者的处理能力。

常用阻塞队列：

threadFactory 创建线程的工厂

handler 拒绝策略

当阻塞队列满了，且没有空闲的工作线程，继续提交任务会采取一种策略处理新任务。线程池提供了4中策略：

1）AbortPolicy：直接抛出异常，默认策略

2）CallerRunsPolicy：用调用者所在的线程来执行任务

3）DiscardPolicy：直接丢弃任务

4）DiscardOldestPolicy：丢弃阻塞队列中最靠前的任务

也可以自己根据应用场景（如记录日志或持久化储存不能处理的任务）实现RejectedExecutionHandler接口，自定义拒绝策略。

3、线程池的工作机制

看下ThreadPoolExecutor的execute方法：

public void execute(Runnable command) {
  if (command == null)
    throw new NullPointerException();

  int c = ctl.get();
  //①当前运行线程数<corePoolSize，则调用addWorker创建线程执行任务
  if (workerCountOf(c) < corePoolSize) {
    if (addWorker(command, true))
      return;
    c = ctl.get();
  }
  //②如果不小于corePoolSize，则将任务添加到workQueue
  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);
  }
  //③放入workQueue失败，则创建线程执行任务，如果创建失败（当前线程数>maximumPoolSize）则拒绝该任务
  else if (!addWorker(command, false))
    reject(command);
}

流程图：


线程池执行流程.png
4、提交任务和关闭线程池

提交任务：

关闭线程池：遍历线程池中的工作线程，然后逐个调用interrupt方法来中断线程。

5、合理配置线程池
上一篇 下一篇

猜你喜欢

热点阅读