public ThreadPoolStats stats() {
List<ThreadPoolStats.Stats> stats = new ArrayList<ThreadPoolStats.Stats>();
for (ExecutorHolder holder : executors.values()) {
String name = holder.info.getName();
// no need to have info on "same" thread pool
if ("same".equals(name)) {
continue;
}
int threads = -1;
int queue = -1;
int active = -1;
long rejected = -1;
int largest = -1;
long completed = -1;
if (holder.executor instanceof ThreadPoolExecutor) {
ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) holder.executor;
threads = threadPoolExecutor.getPoolSize();
queue = threadPoolExecutor.getQueue().size();
active = threadPoolExecutor.getActiveCount();
largest = threadPoolExecutor.getLargestPoolSize();
completed = threadPoolExecutor.getCompletedTaskCount();
RejectedExecutionHandler rejectedExecutionHandler =
threadPoolExecutor.getRejectedExecutionHandler();
if (rejectedExecutionHandler instanceof XRejectedExecutionHandler) {
rejected = ((XRejectedExecutionHandler) rejectedExecutionHandler).rejected();
}
}
stats.add(
new ThreadPoolStats.Stats(name, threads, queue, active, rejected, largest, completed));
}
return new ThreadPoolStats(stats);
}
/** {@inheritDoc} */
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
try {
if (executor.isShutdown()) throw new RejectedExecutionException();
else executor.getQueue().put(r);
} catch (InterruptedException ignored) {
U.warn(log, "Working thread was interrupted while loading data.");
Thread.currentThread().interrupt();
}
}
@Override
public synchronized void close() throws SecurityException {
if (pool.isShutdown()) {
return;
}
try {
// first, anything in the retry queue should be tried one last time and then we give up on it
allowRetry = false;
for (LogglySample sample : retryQueue) {
pool.submit(sample);
}
retryQueue.clear();
System.out.println(
"Shutting down Loggly handler - waiting 90 seconds for "
+ pool.getQueue().size()
+ " logs to finish");
pool.shutdown();
try {
boolean result = pool.awaitTermination(90, TimeUnit.SECONDS);
if (!result) {
System.out.println(
"Not all Loggly messages sent out - still had "
+ pool.getQueue().size()
+ " left :(");
pool.shutdownNow();
}
} catch (InterruptedException e) {
// ignore
}
} finally {
httpClient.getConnectionManager().shutdown();
System.out.println("Loggly handler shut down");
}
}
/**
* Stops the timer, cancelling all tasks
*
* @throws InterruptedException if interrupted while waiting for thread to return
*/
public void stop() {
stopRunner();
List<Runnable> remaining_tasks = pool.shutdownNow();
for (Runnable task : remaining_tasks) {
if (task instanceof Future) {
Future future = (Future) task;
future.cancel(true);
}
}
pool.getQueue().clear();
try {
pool.awaitTermination(Global.THREADPOOL_SHUTDOWN_WAIT_TIME, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
}
}
public void rejectedExecution(Runnable task, ThreadPoolExecutor executor) {
((DebuggableThreadPoolExecutor) executor).onInitialRejection(task);
BlockingQueue<Runnable> queue = executor.getQueue();
while (true) {
if (executor.isShutdown()) {
((DebuggableThreadPoolExecutor) executor).onFinalRejection(task);
throw new RejectedExecutionException("ThreadPoolExecutor has shut down");
}
try {
if (queue.offer(task, 1000, TimeUnit.MILLISECONDS)) {
((DebuggableThreadPoolExecutor) executor).onFinalAccept(task);
break;
}
} catch (InterruptedException e) {
throw new AssertionError(e);
}
}
}
public int getQueueSize() {
return pool.getQueue().size();
}