java线程池中的Worker关键源码

1. 每个Worker主动去workQueue队列里取任务，如果取到任务了就执行
2. 如果没取到，得分以下几种情况：
   • 线程池的线程数大于corePoolSize，非核心线程在等待keepAliveTime后关闭
   • 线程池的线程数小于corePoolSize时：
     • 如果设置了allowCoreThreadTimeOut = true，核心线程在等待keepAliveTime后，也会关闭
     • 如果没有设置allowCoreThreadTimeOut（默认为false），则核心线程阻塞，等待任务到来

注意：核心线程和非核心线程，只是语义上的说法，实际上没有任何区别

Worker关键源码

    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
     
	
		// Worker主方法
		final void runWorker(Worker w) {
     
			Thread wt = Thread.currentThread();
			Runnable task = w.firstTask;
			w.firstTask = null;
			w.unlock(); // allow interrupts
			boolean completedAbruptly = true;
			try {
     
				// 关键代码在于getTask()函数，当allowCoreThreadTimeOut = false && wc <= corePoolSize时，阻塞；否则等待keepAliveTime后返回null，循环结束
				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 {
     
				// 如果循环结束了，说明该Worker可以回收了
				processWorkerExit(w, completedAbruptly);
			}
		}
		
		
		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;
				}
			}
		}
		
		private void processWorkerExit(Worker w, boolean completedAbruptly) {
     
			if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
				decrementWorkerCount();

			final ReentrantLock mainLock = this.mainLock;
			mainLock.lock();
			try {
     
				completedTaskCount += w.completedTasks;
				workers.remove(w);
			} finally {
     
				mainLock.unlock();
			}

			tryTerminate();

			int c = ctl.get();
			if (runStateLessThan(c, STOP)) {
     
				if (!completedAbruptly) {
     
					int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
					if (min == 0 && ! workQueue.isEmpty())
						min = 1;
					if (workerCountOf(c) >= min)
						return; // replacement not needed
				}
				addWorker(null, false);
			}
		}
		
	}