ThreadPoolExecutor源码以及核心的七个参数

ThreadPoolExecutor源码以及核心的七个参数

ThreadPoolExecutor 继承 AbstractExecutorService 抽象类

import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;//可重入锁
import java.util.concurrent.atomic.AtomicInteger;
//四个并发包下的类
 public class ThreadPoolExecutor extends AbstractExecutorService {
    
    
 	// 阻塞队列
	private final BlockingQueue<Runnable> workQueue;
	 //可重入锁
	private final ReentrantLock mainLock = new ReentrantLock();
	
    private final HashSet<Worker> workers = new HashSet<Worker>();
     //work的个数是和历史值取最大值比较,然后取最大值赋值给largestPoolSize.
    private int largestPoolSize;
     
 	private long completedTaskCount;
	//默认线程工厂  volatile 
 	private volatile ThreadFactory threadFactory;
	//拒绝策略执行器 volatile 
	private volatile RejectedExecutionHandler handler;
	
	private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();
        
	//  private volatile boolean allowCoreThreadTimeOut;
	private volatile boolean allowCoreThreadTimeOut;
	// 核心线程数
	private volatile int corePoolSize;
	 // 最大线程数
	private volatile int maximumPoolSize;

 	/* The context to be used when executing the finalizer, or null. */
 	//finalizer 
    private final AccessControlContext acc;

	private static final RuntimePermission shutdownPerm =
        new RuntimePermission("modifyThread");
	  // 内部类  Worker 实现runanble 接口
    private final class Worker
        	extends AbstractQueuedSynchronizer
        	implements Runnable{
    
    
			//序列化 

			/** Thread this worker is running in.  Null if factory fails. */
        	final Thread thread;
        	/** Initial task to run.  Possibly null. */
	        Runnable firstTask;
	        /** Per-thread task counter */
	        volatile long completedTasks;
        	
        	//构造函数
			 Worker(Runnable firstTask) {
    
    
	            setState(-1); // inhibit interrupts until runWorker
	            this.firstTask = firstTask;
	            this.thread = getThreadFactory().newThread(this);
	        }
			/** Delegates main run loop to outer runWorker  */
			// 物理线程执行run 方法
	        public void run() {
    
    
	            runWorker(this);
	        }
	         // Lock methods
        //
        // The value 0 represents the unlocked state.
        // The value 1 represents the locked state.

        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) {
    
    
                }
            }
        }
     }
	// 下面的方法是 是设置contrl 的状态 
	// 核心runWorker 方法
	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);
        }
    }
}

线程池的几个 public 的构造方法以及参数

1. corePoolSize 核心线程数
2. maximumPoolSize 最大线程数
3. keepAliveTime 线程存活时间
4. unit 线程存活时间单位
5. workQueue 阻塞队列，用于存放待执行的任务。
6. threadFactory 线程工厂
7. RejectedExecutionHandler 拒绝策略（4种）
   

 // Public constructors and methods
 // 5 个参数的构造方法 调用 7个参数的构造方法 设置  默认线程工厂，拒绝策略(作用，阻塞) 
//   Executors.defaultThreadFactory() 
//  private static final  RejectedExecutionHandler defaultHandler = new 		AbortPolicy();
  public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
    
    
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
 // 6 个参数的构造方法 调用 7个参数的构造方法 设置  拒绝策略(作用，阻塞) // 
 //  private static final  RejectedExecutionHandler defaultHandler = new 		AbortPolicy();
       
  public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
    
    
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }
 // 6 参数的 构造方法
 // Executors.defaultThreadFactory()
 // handler
 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
    
    
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }
    // 7参数的 构造方法
   public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
    
    
        //  核心线程数，最大线程数小于0 抛出异常
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
            // 判断 工作队列 默认线程工厂、阻塞器 是否为null 抛出空指针
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
         // 判断安全管理器是否为null    
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        // 存活时间，如果太长就抛出异常
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

execute

AtomicInteger ctl

• ctl是一个AtomicInteger修饰的变量，用来保存2个变量：

• workerCount： 线程池中活动线程的数量 runState：线程池的运行状态

workerCountOf（）

• workerCount占用低29位存线程数，workerCount代表了线程池活动的线程数量，最小数量是0，最大的数量是(1 <<COUNT_BITS) - 1 (536870911)；

       private static final int COUNT_BITS = Integer.SIZE - 3;
       private static final int CAPACITY   = (1 << COUNT_BITS) - 1;	
  

• workerCountOf方法是用从ctl中解析出workerCount的值来。由于CAPACITY高3位是000，ctl的值与CAPACITY做&操作的时候，高3位将被舍弃；由于CAPACITY低29位是全是1，&操作会保持原值，这样workerCount的值就从ctl中解析出来了。

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

runState

runState占用高3位存线程状态,共有5个值：

1. RUNNING(-536870912):接受新任务，并处理队列任务
2. SHUTDOWN(0): 不接受新任务，但会处理队列中的任务
3. STOP(536870912): 不接受新任务，不会处理队列任务，中断正在处理的任务
4. TIDYING(1073741824):所有任务已结束，workerCount为0，线程过渡到TIDYING状态，将调用terminated()方法
5. TERMINATED(1610612736): terminated()方法已经完成

   public void execute(Runnable command) {
    
    
   // 为空抛出空指针
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
         // 如果运行的线程少于corePoolSize，尝试开启一个新线程去运行command，command作为这个线程的第一个任务
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
    
    
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //如果任务成功放入队列，我们仍需要一个双重校验去确认是否应该新建一个线程（因为可能存在有些线程在我们上次检查后死了） 或者 从我们进入这个方法后，pool被关闭了
    //所以我们需要再次检查state，如果线程池停止了需要回滚入队列，如果池中没有线程了，新开启 一个线程
        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);
        }
        //如果线程池不是running状态 或者 无法入队列
     * //  尝试开启新线程，扩容至maxPoolSize，如果addWork(command, false)失败了，拒绝当前command
        else if (!addWorker(command, false))
            reject(command);
    }
	/* final void reject(Runnable command) {
        handler.rejectedExecution(command, this);
        // 执行
        void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
    }
  	
     private static final int SHUTDOWN   =  0 << COUNT_BITS;
     // 是否小于  SHUTDOWN
     private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }
  	public boolean remove(Runnable task) {
        boolean removed = workQueue.remove(task);
        tryTerminate(); // In case SHUTDOWN and now empty
        return removed;
    }
      */

tryTerminate

1、判断线程池是否需要进入终止流程（只有当shutdown状态+workQueue.isEmpty 或 stop状态，才需要）

2、判断线程池中是否还有线程，有则 interruptIdleWorkers(ONLY_ONE) 尝试中断一个空闲线程（正是这个逻辑可以再次发出中断信号，中断阻塞在获取任务的线程）

3、如果状态是SHUTDOWN，workQueue也为空了，正在运行的worker也没有了，开始terminated

会先上锁，将线程池置为tidying状态，之后调用需子类实现的 terminated()，最后线程池置为terminated状态，并唤醒所有等待线程池终止这个Condition的线程

   final void tryTerminate() {
    
    
   //这个for循环主要是和进入关闭线程池操作的CAS判断结合使用的
        for (;;) {
    
    
            int c = ctl.get();
       /**
         * 线程池是否需要终止
         * 如果以下3中情况任一为true，return，不进行终止
         * 1、还在运行状态
         * 2、状态是TIDYING、或 TERMINATED，已经终止过了
         * 3、SHUTDOWN 且 workQueue不为空
         */
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
                return;
       /**
         * 只有shutdown状态 且 workQueue为空，或者 stop状态能执行到这一步
         * 如果此时线程池还有线程（正在运行任务，正在等待任务）
         * 中断唤醒一个正在等任务的空闲worker
         * 唤醒后再次判断线程池状态，会return null，进入processWorkerExit()流程
         */
            if (workerCountOf(c) != 0) {
    
     // Eligible to terminate
                interruptIdleWorkers(ONLY_ONE);
                return;
            }
		/**
         * 如果状态是SHUTDOWN，workQueue也为空了，正在运行的worker也没有了，开始terminated
         */
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
    
    
            //CAS：将线程池的ctl变成TIDYING（所有的任务被终止，workCount为0，为此状态时将会调用terminated()方法），期间ctl有变化就会失败，会再次for循环
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
    
    
                    try {
    
    
                        terminated();
                    } finally {
    
    
                        ctl.set(ctlOf(TERMINATED, 0));//将线程池的ctl变成TERMINATED
                        termination.signalAll();//唤醒调用了 等待线程池终止的线程 awaitTermination() 
                    }
                    return;
                }
            } finally {
    
    
                mainLock.unlock();
            }
            // else retry on failed CAS          
        // 如果上面的CAS判断false，再次循环
        }
    }

addWorker

该方法是用来创建，运行，清理Workers的。
检查是否一个新的Worker能否能够添加到当前状态以及给定的范围（包括corePoolSize以及maximumSize）的线程池中。如果可以的话，那么Worker的总数会根据添加的Worker来进行调整，并且如果可能的话，一个新的Worker会被创建，并且启动firstTask作为这个Worker的第一个任务。
当该方法返回false的时候，说明这个当前线程处于Stopped状态或者处于shut down状态或者创建线程失败的时候，会返回false。

1. 获取当前线程池的状态，如果是STOP，TIDYING,TERMINATED状态的话，则会返回false，如果现在状态是SHUTDOWN，但是firstTask不为空或者workQueue为空的话，那么直接返回false。
2. 通过自旋的方式，判断要添加的Worker是否是corePool，如果是的话，那么则判断当前的workerCount是否大于corePoolsize，否则则判断是否大于maximumPoolSize，如果满足的话，说明workerCount超出了线程池大小，直接返回false。如果小于的话，那么判断是否成功将WorkerCount通过CAS操作增加1，如果增加成功的话。则进行到第3步，否则则判断当前线程池的状态，如果现在获取到的状态与进入自旋的状态不一致的话，那么则通过continue
   retry重新进行状态的判断。
3. 如果满足了的话，那么则创建一个新的Worker对象，然后获取线程池的重入锁后，判断当前线程池的状态，如果当前线程池状态为STOP,TIDYING,TERMINATED的话，那么调用decrementWorkerCount将workerCount减一，然后调用tryTerminate停止线程池，并且返回false。
4. 如果状态满足的话，那么则在workers中将新创建的worker添加，并且重新计算largestPoolSize，然后启动Worker中的线程开始执行任务。
   重新Check一次当前线程池的状态，如果处于STOP状态的话，那么就调用interrupt方法中断线程执行。

   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;
    }

	Conditon中的await()对应Object的wait()；
	
	Condition中的signal()对应Object的notify()；
	
	Condition中的signalAll()对应Object的notifyAll()。

ReentrantLock是一个可重入且独占式的锁，它具有与使用synchronized监视器锁相同的基本行为和语义，但与synchronized关键字相比，它更灵活、更强大，增加了轮询、超时、中断等高级功能。ReentrantLock，顾名思义，它是支持可重入锁的锁，是一种递归无阻塞的同步机制。除此之外，该锁还支持获取锁时的公平和非公平选择

AbstractExecutorService 实现 ExecutorService 接口

主要方法有
doInvokeAny（）
newTaskFor（）
submit（）；
invokeAny（）；
invokeAll();

public abstract class AbstractExecutorService implements ExecutorService {
    
    

    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
    
    
        return new FutureTask<T>(runnable, value);
    }
    public Future<?> submit(Runnable task) {
    
    
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }
     private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                              boolean timed, long nanos)
        throws InterruptedException, ExecutionException, TimeoutException {
    
    
        }
}

ExecutorService 继承 Executor 接口

 public interface ExecutorService extends Executor {
    
    
	 void shutdown();
	 
	 List<Runnable> shutdownNow();
	 
	 boolean isShutdown();
	 
	 boolean isTerminated();
	 
	 boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
        
     <T> Future<T> submit(Callable<T> task);
     
	 <T> Future<T> submit(Runnable task, T result);
	 
 	 Future<?> submit(Runnable task);

     <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

  	 <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

 	 <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

	<T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
 }

Executor 接口

public interface Executor {
    
    

    /**
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

若有不正之处请多多谅解，欢迎批评指正、互相讨论。
https://www.jianshu.com/p/3527c91f542d
https://www.cnblogs.com/trust-freedom/p/6594270.html
https://blog.csdn.net/zhoufenqin/article/details/51012666