private void _doAddWorkerThread(Runnable runnable) {
WorkerTask workerTask = new WorkerTask(runnable);
_workerTasks.add(workerTask);
int poolSize = ++_poolSize;
if (poolSize > _largestPoolSize) {
_largestPoolSize = poolSize;
}
workerTask._startWork();
}
public int getActiveCount() {
_mainLock.lock();
try {
int count = 0;
for (WorkerTask workerTask : _workerTasks) {
if (workerTask._isLocked()) {
count++;
}
}
return count;
} finally {
_mainLock.unlock();
}
}
public long getTaskCount() {
_mainLock.lock();
try {
long count = _completedTaskCount;
for (WorkerTask workerTask : _workerTasks) {
count += workerTask._localCompletedTaskCount;
if (workerTask._isLocked()) {
count++;
}
}
return count + _taskQueue.size();
} finally {
_mainLock.unlock();
}
}
public void adjustPoolSize(int newCorePoolSize, int newMaxPoolSize) {
if ((newCorePoolSize < 0) || (newMaxPoolSize <= 0) || (newMaxPoolSize < newCorePoolSize)) {
throw new IllegalArgumentException();
}
_mainLock.lock();
try {
int surplusCoreThreads = _corePoolSize - newCorePoolSize;
int surplusMaxPoolSize = _maxPoolSize - newMaxPoolSize;
_corePoolSize = newCorePoolSize;
_maxPoolSize = newMaxPoolSize;
if (((surplusCoreThreads > 0) && (_poolSize > _corePoolSize))
|| ((surplusMaxPoolSize > 0) && (_poolSize > _maxPoolSize))) {
int interruptCount = Math.max(surplusCoreThreads, surplusMaxPoolSize);
for (WorkerTask workerTask : _workerTasks) {
if (interruptCount > 0) {
if (workerTask._interruptIfWaiting()) {
interruptCount--;
}
} else {
break;
}
}
} else {
Runnable runnable = null;
while ((surplusCoreThreads++ < 0)
&& (_poolSize < _corePoolSize)
&& ((runnable = _taskQueue.poll()) != null)) {
_doAddWorkerThread(runnable);
}
}
} finally {
_mainLock.unlock();
}
}
@Override
public void shutdown() {
_mainLock.lock();
try {
int state = _runState;
if (state < _SHUTDOWN) {
_runState = _SHUTDOWN;
}
for (WorkerTask workerTask : _workerTasks) {
workerTask._interruptIfWaiting();
}
_tryTerminate();
} finally {
_mainLock.unlock();
}
}
