线程池原理解析

最新推荐文章于 2024-10-27 20:58:15 发布

qq_30219537

最新推荐文章于 2024-10-27 20:58:15 发布

阅读量306

点赞数

本文链接：https://blog.youkuaiyun.com/qq_30219537/article/details/82252050

版权

本文深入解析了ThreadPoolTaskExecutor线程池任务执行器，它继承ExecutorConfigurationSupport，实现AsyncListenableTaskExecutor和SchedulingTaskExecutor接口。讨论了其核心属性如同步锁poolSizeMonitor和线程池执行器threadPoolExecutor。还介绍了ThreadPoolExecutor的线程池状态管理，包括线程创建、任务调度和拒绝策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.ThreadPoolTaskExecutor线程池任务执行器

上篇线程池解析中的代码开启多线程执行任务是通过线程池任务执行器ThreadPoolTaskExecutor中的execute（）方法完成待执行的任务。

线程池任务执行器ThreadPoolTaskExecutor继承了ExecutorConfigurationSupport类，ExecutorConfigurationSupport类主要完成，一是创建对象的时候会创建一个执行器服务ExecutorService对象，二是定义了参数设置和执行器的生命周期处理。

线程池任务执行器ThreadPoolTaskExecutor实现了AsyncListenableTaskExecutor、SchedulingTaskExecutor两个接口。

异步执行用户任务的SimpleAsyncTaskExecutor，每次执行客户提交给它的任务时，它会启动新的线程，并允许开发者控制并发线程的上限（concurrencyLimit），从而起到一定的资源节流作用。默认时，concurrencyLimit取值为-1，即不启用资源节流。

SchedulingTaskExecutor接口实现主要判断TaskExecutor任务执行器是喜欢短生命周期任务还是长生命周期任务。

1.1 ThreadPoolTaskExecutor属性介绍

poolSizeMonitor：同步锁对象，当某个线程获取到同步锁，其他线程等待这个线程释放锁，期间核心线程池大小corePoolSize、线程池执行器threadPoolExecutor、最大线程池大小maxPoolSize、线程池执行器生存时间keepAliveSeconds是线程安全的。

threadPoolExecutor：线程池执行器对象，详情请见下节分解。

	@Override
	public void execute(Runnable task) {
        //获取线程池执行器对象 ThreadPoolExecutor
		Executor executor = getThreadPoolExecutor();
		try {
			executor.execute(task);
		}
		catch (RejectedExecutionException ex) {
			throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
		}
	}

    //获取定义的全局threadPoolExecutor对象
	public ThreadPoolExecutor getThreadPoolExecutor() throws IllegalStateException {
		Assert.state(this.threadPoolExecutor != null, "ThreadPoolTaskExecutor not initialized");
		return this.threadPoolExecutor;
	}

    //初始化ThreadPoolTaskExecutor对象的时候执行该方法
	@Override
	protected ExecutorService initializeExecutor(
			ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {
        //创建一个阻塞队列
		BlockingQueue<Runnable> queue = createQueue(this.queueCapacity);
        //构造线程池执行器ThreadPoolExecutor对象
		ThreadPoolExecutor executor  = new ThreadPoolExecutor(
				this.corePoolSize, this.maxPoolSize, this.keepAliveSeconds, TimeUnit.SECONDS,
				queue, threadFactory, rejectedExecutionHandler);
		if (this.allowCoreThreadTimeOut) {
			executor.allowCoreThreadTimeOut(true);
		}
        //将构造的线程池执行器对象传给定义的全局threadPoolExecutor线程池执行器
		this.threadPoolExecutor = executor;
		return executor;
	}

2.ThreadPoolExecutor线程池执行器

2.1 线程池执行器执行任务

/*
1、如果当前运行线程数小于核心池大小，线程池执行器将会尝试开启一个新的线程去执行任务。addWorker这个命令自动会检查运行状态和线程数量，然后阻止那些不应该新增的线程引起的告警。
2、如果一个任务能够成功地添加到队列，我们仍然需要对是否我们本来应该新增一个线程（因为运行的线程自从上次检查后可能已经死亡）或者在进入execute()方法时线程池是否已经关闭进行双重检查。因此我们重新检查线程运行状态，如果线程关闭了，有必要回滚入队的任务或者开启一个新的线程如果不存在的话。
3、如果我们不能将任务添加到队列，我们就需要尝试去新增一个线程。如果失败的话，我们知道线程池被关闭了或者已经饱和了，因此就要拒绝任务。
*/    
public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
      //多线程内存共享value值，volatile类型
        int c = ctl.get();
     //有效线程数量小于核心池大小，如果创建线程执行任务成功就return，失败重新获取内存共享value值
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
    //如果线程池是运行状态同时阻塞队列成功添加任务
        if (isRunning(c) && workQueue.offer(command)) {
            //重新获取共享内存value值
            int recheck = ctl.get();
            //线程池不是运行状态同时删除任务成功就拒绝这个任务
            if (! isRunning(recheck) && remove(command))
                reject(command);
            //有效线程数量为0就添加线程生产者
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
    // 如果添加线程生产者失败就拒绝这个任务
        else if (!addWorker(command, false))
            reject(command);
    }

总结：

1.线程池有以下五个状态：RUNNING（运行） SHUTDOWN（关闭） STOP（停止） TIDYING（整理） TERMINATED（终止）。
2.如果有效线程数量小于核心池大小，创建线程执行任务成功就结束；
3.创建线程执行任务失败重新获取内存共享value值；
- 如果线程池是运行状态同时阻塞队列成功添加任务；再次检查发现如果不是运行状态且删除任务成功，拒绝任务，如果有效线程数量为0就添加线程生产者；
- 如果添加线程生产者失败就拒绝这个任务；

2.2 创建线程生产者

/*
当考虑到当前线程池的状态和给定的组合（核心线程池或者最大）时，检查是否一个新的线程创建生产者能够被创建。如果可以，线程创建生产者数会自动被调整，如果可能的话，一个新的生产者被创建并开启一个新线程，
运行firstTask这个任务。如果线程池被停了或者合法地关闭了，这个方法返回false。当被请求时，如果线程工厂创建一个线程失败，这个方法也会返回false。如果这个线程创建失败，或者由于线程工厂返回为null，或者发生了异常（典型的Thread.start()启动线程报OutOfMemoryError），我们都会有规则地回滚。
*/
/*@param firstTask:新创建的线程应该最先执行这个任务（或者为null如果没有的话）。当线程数少于核心线程数（在这种情况下我们总是开启一个）的时候或者当队列满的时候（在这种情况下我们必须疏通队列），为了疏通队列，线程生产者被创建同时执行初始化任务。初始的空闲线程通常被创建通过预启动核心线程或者去替换其他正在死亡的创建线程生产者。
*/
/*
  @param core:如果参数core为true，使用corePoolSize，否则使用maximumPoolSize。（在检测其他pool的状态之后，一个布尔指示器被用在这里而不是用一个value来确保刷新后的values的计数）
*/
private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            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 {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    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;
    }