如何从线程池中取线程，运行代码

源码

executor方法

// 存放线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

private static int workerCountOf(int c) {
    return c & CAPACITY;
}

private final BlockingQueue<Runnable> workQueue;

public void execute(Runnable command) {
    // 如果任务为null，则抛出异常。
    if (command == null)
        throw new NullPointerException();
    // ctl 中保存的线程池当前的一些状态信息
    int c = ctl.get();

    //  下面会涉及到 3 步 操作
    // 1.首先判断当前线程池中执行的任务数量是否小于 corePoolSize
    // 如果小于的话，通过addWorker(command, true)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 2.如果当前执行的任务数量大于等于 corePoolSize 的时候就会走到这里
    // 通过 isRunning 方法判断线程池状态，线程池处于 RUNNING 状态才会被并且队列可以加入任务，该任务才会被加入进去
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 再次获取线程池状态，如果线程池状态不是 RUNNING 状态就需要从任务队列中移除任务，并尝试判断线程是否全部执行完毕。同时执行拒绝策略。
        if (!isRunning(recheck) && remove(command))
            reject(command);
            // 如果当前线程池为空就新创建一个线程并执行。
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    //3. 通过addWorker(command, false)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
    //如果addWorker(command, false)执行失败，则通过reject()执行相应的拒绝策略的内容。
    else if (!addWorker(command, false))
        reject(command);
}

addWorker方法

worker类

worker实现了runable接口，构造方法通过线程工厂获得线程

通过runable的run方法执行任务

private final class Worker  
    extends AbstractQueuedSynchronizer  
    implements Runnable  
{  
            /**  
 	 * This class will never be serialized, but we provide a 
	 * serialVersionUID to suppress a javac warning. 
	 */ 
 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;  
	// 通过ThreadFactory创建新线程，此处默认为DefaultThreadFactory
 	this.thread = getThreadFactory().newThread(this);  
    }

 }

当调用ThreadPoolExecutor的execute()方法时，会调用addWorker()方法;
addWorker()中会创建Worker类的实例，该实例对线程池中的线程进行了包装，其实现了Runnable接口，Worker实例创建成功后会调用线程的start()方法；
在Worker的run方法中通过runTask()方法执行任务，并循环通过getTask()方法获取队列中等待的任务去执行。

执行方法

在executor中获得worker的线程t

调用t.start这样worker中的线程就会被唤醒不断的执行run方法

获取队列

worker在执行run方法的时候不断的

通过getTask方法从等待队列中获取任务

如果获取不到就自旋

private Runnable getTask() {
	
	// ...省略
	
	try {  
		// 此处通过任务队列获取下一个任务并返回
    	Runnable r = timed ?  
        workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :  
        workQueue.take();  
 		if (r != null)  
        	return r;  
 		timedOut = true;  
	} catch (InterruptedException retry) {  
    	timedOut = false;  
	}

	// ....省略
}

原文在下
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/qq_32777253/article/details/122225408