Quartz SimpleThreadPool的源码,一个简单的线程池的实现原理
The pool has a fixed number of Thread s, and does not grow or shrink based on demand.(固定大小的线程池，不会增加，不会减少)
由于这个线程池的特性比较简单，易于我们去理解线程池，线程池的使用就是为了减少每次创建关闭的开销，节约资源反对浪费
线程池中的主要资源就是工作的线程，能够调用已经创建好的线程，去执行特定的方法，所以线程池需要对于这些线程的资源进行统一的管理
统一管理中的线程就包含了工作的线程，可用的线程，总的线程资源
- SimpleThreadPool中可用资源的表示
private List< WorkerThread> workers;//总的线程
private LinkedList< WorkerThread> availWorkers = new LinkedList< WorkerThread>();//可用的线程
private LinkedList< WorkerThread> busyWorkers = new LinkedList< WorkerThread>();//工作中的线程资源- 一般的线程实现无疑就是继承Thread和实现Runable两种方法
import lombok.extern.slf4j.Slf4j;
/**
* descrption: 简单的线程实例
* authohr: wangji
* date: 2017-08-23 14:22
*/
@Slf4j
public class MyThread extends Thread {
@Override
public void run() {
log.info("线程run.....");
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
}
}
这里的线程执行完了之后就回收了线程的资源..和我们的线程池的资源是有区别的，线程池的资源是一直保持运行的状态，没有被回收,看看WorkerThread的实现
工作的线程的实现WorkerThread( WorkerThread extends Thread )
- WorkerThread的成员变量
private final Object lock = new Object(); //锁
// A flag that signals the WorkerThread to terminate.
private AtomicBoolean run = new AtomicBoolean(true);//运行关闭状态量
private SimpleThreadPool tp;//当前线程池的引用，用来回收可用的线程资源availWorkers
private Runnable runnable = null;//真正执行的Runable中的run方法，线程当前执行的方法
private boolean runOnce = false;//是否执行一次- 构造函数(设置是否守护进程，是否执行一次，设置线程的优先级)
/**
* Create a worker thread and start it. Waiting for the next Runnable,
* executing it, and waiting for the next Runnable, until the shutdown
* flag is set.
*/
WorkerThread(SimpleThreadPool tp, ThreadGroup threadGroup, String name,
int prio, boolean isDaemon) {
this(tp, threadGroup, name, prio, isDaemon, null);
}
/**
* Create a worker thread, start it, execute the runnable and terminate
* the thread (one time execution).
*/
WorkerThread(SimpleThreadPool tp, ThreadGroup threadGroup, String name,
int prio, boolean isDaemon, Runnable runnable) {
super(threadGroup, name);
this.tp = tp;
this.runnable = runnable;
if(runnable != null)
runOnce = true;
setPriority(prio);
setDaemon(isDaemon);
}
- 循环的执行Run,让线程永不停息(这样才线程的资源不会被回收)，通过状态量控制线程的终止
/**
* Loop, executing targets as they are received.
*/
@Override
public void run() {
boolean ran = false;
while (run.get()) {//状态量控制其终止状态
try {
synchronized(lock) {
while (runnable == null && run.get()) {
lock.wait(500);
//导致线程进入等待状态直到它被通知或者经过指定的时间
//没有可以执行的东西，就休息....
}
if (runnable != null) {
ran = true;
runnable.run();
}
}
} catch (InterruptedException unblock) {//忽略中断的异常
// do nothing (loop will terminate if shutdown() was called
try {
getLog().error("Worker thread was interrupt()'ed.", unblock);
} catch(Exception e) {
// ignore to help with a tomcat glitch
}
} catch (Throwable exceptionInRunnable) {
try {
getLog().error("Error while executing the Runnable: ",
exceptionInRunnable);
} catch(Exception e) {
// ignore to help with a tomcat glitch
}
} finally {
synchronized(lock) {//执行完了，将当前的runable,设置为空
runnable = null;
}
// repair the thread in case the runnable mucked it up...
if(getPriority() != tp.getThreadPriority()) {
setPriority(tp.getThreadPriority());
}
if (runOnce) {//只执行一次，将当前Loop状态量设置false
run.set(false);
clearFromBusyWorkersList(this);//从工作线程中清除，只执行一次的
} else if(ran) {
ran = false;
makeAvailable(this);//工作线程变为可用
}
}
}
}
}
//这两个方法就是执行线程的方法完成后，修改可用的工作线程，然后通知有这个nextRunnableLock锁的执行
//如果之前有线程在等待去执行，那么就会一直等待哦，知道这里的工作线程通知执行，都是同步执行哦
protected void makeAvailable(WorkerThread wt) {
synchronized(nextRunnableLock) {
if(!isShutdown) {
availWorkers.add(wt);
}
busyWorkers.remove(wt);
nextRunnableLock.notifyAll();
}
}
protected void clearFromBusyWorkersList(WorkerThread wt) {
synchronized(nextRunnableLock) {
busyWorkers.remove(wt);
nextRunnableLock.notifyAll();
}
}
- SimpleThreadPool怎么通知工作线程执行呢
当前WorKThread的一个方法，去设置runable，然后就可以通知阻塞的工作线程去执行方法啦
public void run(Runnable newRunnable) {
synchronized(lock) {
if(runnable != null) {
throw new IllegalStateException("Already running a Runnable!");
}
runnable = newRunnable;
lock.notifyAll();//通知run方法中阻塞的方法执行哦！Loop方法就可以来玩了
}
}- WorkThread终止的方法,就是设置其状态量，不再去Loop,线程执行完毕就终止了
/**
* <p>
* Signal the thread that it should terminate.
* </p>
*/
void shutdown() {
run.set(false);
}- WorkThread的完整的方法
/**
* <p>
* A Worker loops, waiting to execute tasks.
* </p>
*/
class WorkerThread extends Thread {
private final Object lock = new Object();
// A flag that signals the WorkerThread to terminate.
private AtomicBoolean run = new AtomicBoolean(true);
private SimpleThreadPool tp;
private Runnable runnable = null;
private boolean runOnce = false;
/**
* <p>
* Create a worker thread and start it. Waiting for the next Runnable,
* executing it, and waiting for the next Runnable, until the shutdown
* flag is set.
* </p>
*/
WorkerThread(SimpleThreadPool tp, ThreadGroup threadGroup, String name,
int prio, boolean isDaemon) {
this(tp, threadGroup, name, prio, isDaemon, null);
}
/**
* <p>
* Create a worker thread, start it, execute the runnable and terminate
* the thread (one time execution).
* </p>
*/
WorkerThread(SimpleThreadPool tp, ThreadGroup threadGroup, String name,
int prio, boolean isDaemon, Runnable runnable) {
super(threadGroup, name);
this.tp = tp;
this.runnable = runnable;
if(runnable != null)
runOnce = true;
setPriority(prio);
setDaemon(isDaemon);
}
/**
* <p>
* Signal the thread that it should terminate.
* </p>
*/
void shutdown() {
run.set(false);
}
public void run(Runnable newRunnable) {
synchronized(lock) {
if(runnable != null) {
throw new IllegalStateException("Already running a Runnable!");
}
runnable = newRunnable;
lock.notifyAll();
}
}
/**
* <p>
* Loop, executing targets as they are received.
* </p>
*/
@Override
public void run() {
boolean ran = false;
while (run.get()) {
try {
synchronized(lock) {
while (runnable == null && run.get()) {
lock.wait(500);
}
if (runnable != null) {
ran = true;
runnable.run();
}
}
} catch (InterruptedException unblock) {
// do nothing (loop will terminate if shutdown() was called
try {
getLog().error("Worker thread was interrupt()'ed.", unblock);
} catch(Exception e) {
// ignore to help with a tomcat glitch
}
} catch (Throwable exceptionInRunnable) {
try {
getLog().error("Error while executing the Runnable: ",
exceptionInRunnable);
} catch(Exception e) {
// ignore to help with a tomcat glitch
}
} finally {
synchronized(lock) {
runnable = null;
}
// repair the thread in case the runnable mucked it up...
if(getPriority() != tp.getThreadPriority()) {
setPriority(tp.getThreadPriority());
}
if (runOnce) {
run.set(false);
clearFromBusyWorkersList(this);
} else if(ran) {
ran = false;
makeAvailable(this);
}
}
}
//if (log.isDebugEnabled())
try {
getLog().debug("WorkerThread is shut down.");
} catch(Exception e) {
// ignore to help with a tomcat glitch
}
}
}
}
SimpleThread主要的初始化方法，初始化线程放置在List< WorkThread> 中去
- 初始化共享的线程
public void initialize() throws SchedulerConfigException {
if(workers != null && workers.size() > 0) // already initialized...
return;
if (count <= 0) {
throw new SchedulerConfigException(
"Thread count must be > 0");
}
if (prio <= 0 || prio > 9) {
throw new SchedulerConfigException(
"Thread priority must be > 0 and <= 9");
}
//设置线程组
if(isThreadsInheritGroupOfInitializingThread()) {
threadGroup = Thread.currentThread().getThreadGroup();
} else {
// follow the threadGroup tree to the root thread group.
threadGroup = Thread.currentThread().getThreadGroup();
ThreadGroup parent = threadGroup;
while ( !parent.getName().equals("main") ) {
threadGroup = parent;
parent = threadGroup.getParent();
}
threadGroup = new ThreadGroup(parent, schedulerInstanceName + "-SimpleThreadPool");
if (isMakeThreadsDaemons()) {
threadGroup.setDaemon(true);
}
}
//创建工作线程，然后start他们，这里没有设置runable，所以是不止执行一次哦！
// create the worker threads and start them
Iterator<WorkerThread> workerThreads = createWorkerThreads(count).iterator();
while(workerThreads.hasNext()) {
WorkerThread wt = workerThreads.next();
wt.start();
availWorkers.add(wt);
}
}
protected List<WorkerThread> createWorkerThreads(int createCount) {
workers = new LinkedList<WorkerThread>();
for (int i = 1; i<= createCount; ++i) {
String threadPrefix = getThreadNamePrefix();
if (threadPrefix == null) {
threadPrefix = schedulerInstanceName + "_Worker";
}
WorkerThread wt = new WorkerThread(this, threadGroup,
threadPrefix + "-" + i,
getThreadPriority(),
isMakeThreadsDaemons());
if (isThreadsInheritContextClassLoaderOfInitializingThread()) {
wt.setContextClassLoader(Thread.currentThread()
.getContextClassLoader());
}
workers.add(wt);
}
return workers;
}
- 让线程池运行一个任务,都是通过锁阻塞来实现线程间的通信。
public boolean runInThread(Runnable runnable) {
if (runnable == null) {
return false;
}
synchronized (nextRunnableLock) {
handoffPending = true;
// Wait until a worker thread is available
//阻塞等待，直到有线程可用
while ((availWorkers.size() < 1) && !isShutdown) {
try {
nextRunnableLock.wait(500);
} catch (InterruptedException ignore) {
}
}
if (!isShutdown) {
WorkerThread wt = (WorkerThread)availWorkers.removeFirst();
busyWorkers.add(wt);
wt.run(runnable);
} else {
//这里的意思就是，如果已经关闭了，还有请求来了，创建一个新的线程来执行
// If the thread pool is going down, execute the Runnable
// within a new additional worker thread (no thread from the pool).
WorkerThread wt = new WorkerThread(this, threadGroup,
"WorkerThread-LastJob", prio, isMakeThreadsDaemons(), runnable);
busyWorkers.add(wt);
workers.add(wt);
wt.start();
}
nextRunnableLock.notifyAll();
handoffPending = false;
}
return true;
}- 和平的关闭所有的线程？
public void shutdown(boolean waitForJobsToComplete) {
synchronized (nextRunnableLock) {
getLog().debug("Shutting down threadpool...");
isShutdown = true;
if(workers == null) // case where the pool wasn't even initialize()ed
return;
// signal each worker thread to shut down
//将所有可用的线程移除掉！
Iterator<WorkerThread> workerThreads = workers.iterator();
while(workerThreads.hasNext()) {
WorkerThread wt = workerThreads.next();
wt.shutdown();
availWorkers.remove(wt);
}
// Give waiting (wait(1000)) worker threads a chance to shut down.
// Active worker threads will shut down after finishing their
// current job.
nextRunnableLock.notifyAll();//让其他阻塞的线程执行完成
if (waitForJobsToComplete == true) {
boolean interrupted = false;
try {
// wait for hand-off in runInThread to complete...
while(handoffPending) {
try {
nextRunnableLock.wait(100);
} catch(InterruptedException _) {
interrupted = true;
}
}
// Wait until all worker threads are shut down
while (busyWorkers.size() > 0) {//一直等待线程执行完成
WorkerThread wt = (WorkerThread) busyWorkers.getFirst();
try {
getLog().debug(
"Waiting for thread " + wt.getName()
+ " to shut down");
// note: with waiting infinite time the
// application may appear to 'hang'.
nextRunnableLock.wait(2000);
} catch (InterruptedException _) {
interrupted = true;
}
}
workerThreads = workers.iterator();
while(workerThreads.hasNext()) {
WorkerThread wt = (WorkerThread) workerThreads.next();
try {
wt.join();
workerThreads.remove();
} catch (InterruptedException _) {
interrupted = true;
}
}
} finally {
if (interrupted) {
Thread.currentThread().interrupt();
}
}
getLog().debug("No executing jobs remaining, all threads stopped.");
}
getLog().debug("Shutdown of threadpool complete.");
}
}总结
看过源码之后，清楚的了解线程池维护的整个过程，由于这里没有涉及线程的增加的维护问题，整个代码使用wait和notify维持线程间的同步执行问题
对于共享线程的原理时使用Loop+wait+notify，当有线程执行的时候，被唤醒执行任务。
源码 SimpleThreadPool
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.2</version>
</dependency>//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.quartz.simpl;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import org.quartz.SchedulerConfigException;
import org.quartz.spi.ThreadPool;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SimpleThreadPool implements ThreadPool {
private int count = -1;
private int prio = 5;
private boolean isShutdown = false;
private boolean handoffPending = false;
private boolean inheritLoader = false;
private boolean inheritGroup = true;
private boolean makeThreadsDaemons = false;
private ThreadGroup threadGroup;
private final Object nextRunnableLock = new Object();
private List<SimpleThreadPool.WorkerThread> workers;
private LinkedList<SimpleThreadPool.WorkerThread> availWorkers = new LinkedList();
private LinkedList<SimpleThreadPool.WorkerThread> busyWorkers = new LinkedList();
private String threadNamePrefix;
private final Logger log = LoggerFactory.getLogger(this.getClass());
private String schedulerInstanceName;
public SimpleThreadPool() {
}
public SimpleThreadPool(int threadCount, int threadPriority) {
this.setThreadCount(threadCount);
this.setThreadPriority(threadPriority);
}
public Logger getLog() {
return this.log;
}
public int getPoolSize() {
return this.getThreadCount();
}
public void setThreadCount(int count) {
this.count = count;
}
public int getThreadCount() {
return this.count;
}
public void setThreadPriority(int prio) {
this.prio = prio;
}
public int getThreadPriority() {
return this.prio;
}
public void setThreadNamePrefix(String prfx) {
this.threadNamePrefix = prfx;
}
public String getThreadNamePrefix() {
return this.threadNamePrefix;
}
public boolean isThreadsInheritContextClassLoaderOfInitializingThread() {
return this.inheritLoader;
}
public void setThreadsInheritContextClassLoaderOfInitializingThread(boolean inheritLoader) {
this.inheritLoader = inheritLoader;
}
public boolean isThreadsInheritGroupOfInitializingThread() {
return this.inheritGroup;
}
public void setThreadsInheritGroupOfInitializingThread(boolean inheritGroup) {
this.inheritGroup = inheritGroup;
}
public boolean isMakeThreadsDaemons() {
return this.makeThreadsDaemons;
}
public void setMakeThreadsDaemons(boolean makeThreadsDaemons) {
this.makeThreadsDaemons = makeThreadsDaemons;
}
public void setInstanceId(String schedInstId) {
}
public void setInstanceName(String schedName) {
this.schedulerInstanceName = schedName;
}
public void initialize() throws SchedulerConfigException {
if(this.workers == null || this.workers.size() <= 0) {
if(this.count <= 0) {
throw new SchedulerConfigException("Thread count must be > 0");
} else if(this.prio > 0 && this.prio <= 9) {
if(this.isThreadsInheritGroupOfInitializingThread()) {
this.threadGroup = Thread.currentThread().getThreadGroup();
} else {
this.threadGroup = Thread.currentThread().getThreadGroup();
ThreadGroup workerThreads;
for(workerThreads = this.threadGroup; !workerThreads.getName().equals("main"); workerThreads = this.threadGroup.getParent()) {
this.threadGroup = workerThreads;
}
this.threadGroup = new ThreadGroup(workerThreads, this.schedulerInstanceName + "-SimpleThreadPool");
if(this.isMakeThreadsDaemons()) {
this.threadGroup.setDaemon(true);
}
}
if(this.isThreadsInheritContextClassLoaderOfInitializingThread()) {
this.getLog().info("Job execution threads will use class loader of thread: " + Thread.currentThread().getName());
}
Iterator workerThreads1 = this.createWorkerThreads(this.count).iterator();
while(workerThreads1.hasNext()) {
SimpleThreadPool.WorkerThread wt = (SimpleThreadPool.WorkerThread)workerThreads1.next();
wt.start();
this.availWorkers.add(wt);
}
} else {
throw new SchedulerConfigException("Thread priority must be > 0 and <= 9");
}
}
}
protected List<SimpleThreadPool.WorkerThread> createWorkerThreads(int createCount) {
this.workers = new LinkedList();
for(int i = 1; i <= createCount; ++i) {
String threadPrefix = this.getThreadNamePrefix();
if(threadPrefix == null) {
threadPrefix = this.schedulerInstanceName + "_Worker";
}
SimpleThreadPool.WorkerThread wt = new SimpleThreadPool.WorkerThread(this, this.threadGroup, threadPrefix + "-" + i, this.getThreadPriority(), this.isMakeThreadsDaemons());
if(this.isThreadsInheritContextClassLoaderOfInitializingThread()) {
wt.setContextClassLoader(Thread.currentThread().getContextClassLoader());
}
this.workers.add(wt);
}
return this.workers;
}
public void shutdown() {
this.shutdown(true);
}
public void shutdown(boolean waitForJobsToComplete) {
Object var2 = this.nextRunnableLock;
synchronized(this.nextRunnableLock) {
this.getLog().debug("Shutting down threadpool...");
this.isShutdown = true;
if(this.workers != null) {
Iterator workerThreads = this.workers.iterator();
while(workerThreads.hasNext()) {
SimpleThreadPool.WorkerThread interrupted = (SimpleThreadPool.WorkerThread)workerThreads.next();
interrupted.shutdown();
this.availWorkers.remove(interrupted);
}
this.nextRunnableLock.notifyAll();
if(waitForJobsToComplete) {
boolean interrupted1 = false;
try {
while(this.handoffPending) {
try {
this.nextRunnableLock.wait(100L);
} catch (InterruptedException var16) {
interrupted1 = true;
}
}
SimpleThreadPool.WorkerThread wt;
while(this.busyWorkers.size() > 0) {
wt = (SimpleThreadPool.WorkerThread)this.busyWorkers.getFirst();
try {
this.getLog().debug("Waiting for thread " + wt.getName() + " to shut down");
this.nextRunnableLock.wait(2000L);
} catch (InterruptedException var15) {
interrupted1 = true;
}
}
workerThreads = this.workers.iterator();
while(workerThreads.hasNext()) {
wt = (SimpleThreadPool.WorkerThread)workerThreads.next();
try {
wt.join();
workerThreads.remove();
} catch (InterruptedException var14) {
interrupted1 = true;
}
}
} finally {
if(interrupted1) {
Thread.currentThread().interrupt();
}
}
this.getLog().debug("No executing jobs remaining, all threads stopped.");
}
this.getLog().debug("Shutdown of threadpool complete.");
}
}
}
public boolean runInThread(Runnable runnable) {
if(runnable == null) {
return false;
} else {
Object var2 = this.nextRunnableLock;
synchronized(this.nextRunnableLock) {
this.handoffPending = true;
while(this.availWorkers.size() < 1 && !this.isShutdown) {
try {
this.nextRunnableLock.wait(500L);
} catch (InterruptedException var5) {
;
}
}
SimpleThreadPool.WorkerThread wt;
if(!this.isShutdown) {
wt = (SimpleThreadPool.WorkerThread)this.availWorkers.removeFirst();
this.busyWorkers.add(wt);
wt.run(runnable);
} else {
wt = new SimpleThreadPool.WorkerThread(this, this.threadGroup, "WorkerThread-LastJob", this.prio, this.isMakeThreadsDaemons(), runnable);
this.busyWorkers.add(wt);
this.workers.add(wt);
wt.start();
}
this.nextRunnableLock.notifyAll();
this.handoffPending = false;
return true;
}
}
}
public int blockForAvailableThreads() {
Object var1 = this.nextRunnableLock;
synchronized(this.nextRunnableLock) {
while((this.availWorkers.size() < 1 || this.handoffPending) && !this.isShutdown) {
try {
this.nextRunnableLock.wait(500L);
} catch (InterruptedException var4) {
;
}
}
return this.availWorkers.size();
}
}
protected void makeAvailable(SimpleThreadPool.WorkerThread wt) {
Object var2 = this.nextRunnableLock;
synchronized(this.nextRunnableLock) {
if(!this.isShutdown) {
this.availWorkers.add(wt);
}
this.busyWorkers.remove(wt);
this.nextRunnableLock.notifyAll();
}
}
protected void clearFromBusyWorkersList(SimpleThreadPool.WorkerThread wt) {
Object var2 = this.nextRunnableLock;
synchronized(this.nextRunnableLock) {
this.busyWorkers.remove(wt);
this.nextRunnableLock.notifyAll();
}
}
class WorkerThread extends Thread {
private final Object lock;
private AtomicBoolean run;
private SimpleThreadPool tp;
private Runnable runnable;
private boolean runOnce;
WorkerThread(SimpleThreadPool tp, ThreadGroup threadGroup, String name, int prio, boolean isDaemon) {
this(tp, threadGroup, name, prio, isDaemon, (Runnable)null);
}
WorkerThread(SimpleThreadPool tp, ThreadGroup threadGroup, String name, int prio, boolean isDaemon, Runnable runnable) {
super(threadGroup, name);
this.lock = new Object();
this.run = new AtomicBoolean(true);
this.runnable = null;
this.runOnce = false;
this.tp = tp;
this.runnable = runnable;
if(runnable != null) {
this.runOnce = true;
}
this.setPriority(prio);
this.setDaemon(isDaemon);
}
void shutdown() {
this.run.set(false);
}
public void run(Runnable newRunnable) {
Object var2 = this.lock;
synchronized(this.lock) {
if(this.runnable != null) {
throw new IllegalStateException("Already running a Runnable!");
} else {
this.runnable = newRunnable;
this.lock.notifyAll();
}
}
}
public void run() {
boolean ran = false;
while(this.run.get()) {
boolean var21 = false;
Object e2;
label288: {
label289: {
try {
var21 = true;
e2 = this.lock;
synchronized(this.lock) {
while(this.runnable == null && this.run.get()) {
this.lock.wait(500L);
}
if(this.runnable != null) {
ran = true;
this.runnable.run();
}
var21 = false;
break label288;
}
} catch (InterruptedException var30) {
InterruptedException e1 = var30;
try {
SimpleThreadPool.this.getLog().error("Worker thread was interrupt()\'ed.", e1);
var21 = false;
} catch (Exception var27) {
var21 = false;
}
break label289;
} catch (Throwable var31) {
Throwable e = var31;
try {
SimpleThreadPool.this.getLog().error("Error while executing the Runnable: ", e);
var21 = false;
} catch (Exception var25) {
var21 = false;
}
} finally {
if(var21) {
Object var8 = this.lock;
synchronized(this.lock) {
this.runnable = null;
}
if(this.getPriority() != this.tp.getThreadPriority()) {
this.setPriority(this.tp.getThreadPriority());
}
if(this.runOnce) {
this.run.set(false);
SimpleThreadPool.this.clearFromBusyWorkersList(this);
} else if(ran) {
ran = false;
SimpleThreadPool.this.makeAvailable(this);
}
}
}
e2 = this.lock;
synchronized(this.lock) {
this.runnable = null;
}
if(this.getPriority() != this.tp.getThreadPriority()) {
this.setPriority(this.tp.getThreadPriority());
}
if(this.runOnce) {
this.run.set(false);
SimpleThreadPool.this.clearFromBusyWorkersList(this);
} else if(ran) {
ran = false;
SimpleThreadPool.this.makeAvailable(this);
}
continue;
}
e2 = this.lock;
synchronized(this.lock) {
this.runnable = null;
}
if(this.getPriority() != this.tp.getThreadPriority()) {
this.setPriority(this.tp.getThreadPriority());
}
if(this.runOnce) {
this.run.set(false);
SimpleThreadPool.this.clearFromBusyWorkersList(this);
} else if(ran) {
ran = false;
SimpleThreadPool.this.makeAvailable(this);
}
continue;
}
e2 = this.lock;
synchronized(this.lock) {
this.runnable = null;
}
if(this.getPriority() != this.tp.getThreadPriority()) {
this.setPriority(this.tp.getThreadPriority());
}
if(this.runOnce) {
this.run.set(false);
SimpleThreadPool.this.clearFromBusyWorkersList(this);
} else if(ran) {
ran = false;
SimpleThreadPool.this.makeAvailable(this);
}
}
try {
SimpleThreadPool.this.getLog().debug("WorkerThread is shut down.");
} catch (Exception var23) {
;
}
}
}
}
扫一扫
1045
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
