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

你可能感兴趣的:(Java,java,线程池,Worker,源码)