Java ThreadPoolExecutor类代码示例

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
public void shutdownExecutor() {
    if ( executor!=null && internalExecutor ) {
        if ( executor instanceof ThreadPoolExecutor ) {
            //this is our internal one, so we need to shut it down
            ThreadPoolExecutor tpe = (ThreadPoolExecutor) executor;
            tpe.shutdownNow();
            long timeout = getExecutorTerminationTimeoutMillis();
            if (timeout > 0) {
                try {
                    tpe.awaitTermination(timeout, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    // Ignore
                }
                if (tpe.isTerminating()) {
                    getLog().warn(sm.getString("endpoint.warn.executorShutdown", getName()));
                }
            }
            TaskQueue queue = (TaskQueue) tpe.getQueue();
            queue.setParent(null);
        }
        executor = null;
    }
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
@Override
public void onApplicationEvent(ContextClosedEvent event) {
    this.connector.pause();
    Executor executor = this.connector.getProtocolHandler().getExecutor();
    if (executor instanceof ThreadPoolExecutor) {
        try {
            ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executor;
            threadPoolExecutor.shutdown();
            if (!threadPoolExecutor.awaitTermination(30, TimeUnit.SECONDS)) {
                log.warn("Tomcat thread pool did not shut down gracefully within "
                        + "30 seconds. Proceeding with forceful shutdown");
            }
        }
        catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
        }
    }
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
@Override
public void onApplicationEvent(ContextClosedEvent event) {
	log.info("Starting graceful shutdown of Tomcat");
	if (this.connector != null)
	{
		this.connector.pause();
        Executor executor = this.connector.getProtocolHandler().getExecutor();
        if (executor instanceof ThreadPoolExecutor) {
            try {
                ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executor;
                threadPoolExecutor.shutdown();
                if (!threadPoolExecutor.awaitTermination(20, TimeUnit.SECONDS)) {
                    log.warn("Tomcat thread pool did not shut down gracefully within "
                            + "20 seconds. Proceeding with forceful shutdown");
                }
                else
                {
                    log.info("Thread pool has closed");
                }
            }
            catch (InterruptedException ex) {
                Thread.currentThread().interrupt();
            }
        }
	}
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
/**
 * Start the component and implement the requirements of
 * {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
 *
 * @exception LifecycleException
 *                if this component detects a fatal error that prevents this
 *                component from being used
 */
@Override
protected void startInternal() throws LifecycleException {

	taskqueue = new TaskQueue(maxQueueSize);
	TaskThreadFactory tf = new TaskThreadFactory(namePrefix, daemon, getThreadPriority());
	executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), maxIdleTime, TimeUnit.MILLISECONDS,
			taskqueue, tf);
	executor.setThreadRenewalDelay(threadRenewalDelay);
	if (prestartminSpareThreads) {
		executor.prestartAllCoreThreads();
	}
	taskqueue.setParent(executor);

	setState(LifecycleState.STARTING);
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
private static AsynchronousChannelGroup createAsynchronousChannelGroup() {
	// Need to do this with the right thread context class loader else the
	// first web app to call this will trigger a leak
	ClassLoader original = Thread.currentThread().getContextClassLoader();

	try {
		Thread.currentThread().setContextClassLoader(AsyncIOThreadFactory.class.getClassLoader());

		// These are the same settings as the default
		// AsynchronousChannelGroup
		int initialSize = Runtime.getRuntime().availableProcessors();
		ExecutorService executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, Long.MAX_VALUE,
				TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>(), new AsyncIOThreadFactory());

		try {
			return AsynchronousChannelGroup.withCachedThreadPool(executorService, initialSize);
		} catch (IOException e) {
			// No good reason for this to happen.
			throw new IllegalStateException(sm.getString("asyncChannelGroup.createFail"));
		}
	} finally {
		Thread.currentThread().setContextClassLoader(original);
	}
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
public void shutdownExecutor() {
	if (executor != null && internalExecutor) {
		if (executor instanceof ThreadPoolExecutor) {
			// this is our internal one, so we need to shut it down
			ThreadPoolExecutor tpe = (ThreadPoolExecutor) executor;
			tpe.shutdownNow();
			long timeout = getExecutorTerminationTimeoutMillis();
			if (timeout > 0) {
				try {
					tpe.awaitTermination(timeout, TimeUnit.MILLISECONDS);
				} catch (InterruptedException e) {
					// Ignore
				}
				if (tpe.isTerminating()) {
					getLog().warn(sm.getString("endpoint.warn.executorShutdown", getName()));
				}
			}
			TaskQueue queue = (TaskQueue) tpe.getQueue();
			queue.setParent(null);
		}
		executor = null;
	}
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
@Override
public void onApplicationEvent(ContextClosedEvent event) {
    this.connector.pause();
    log.info("Shutting Down LivingDoc Remote Agent");
    Executor executor = this.connector.getProtocolHandler().getExecutor();
    if (executor instanceof ThreadPoolExecutor) {
        try {
            ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executor;
            threadPoolExecutor.shutdown();
            if (!threadPoolExecutor.awaitTermination(30, TimeUnit.SECONDS)) {
                log.warn("Tomcat thread pool did not shut down gracefully within "
                        + "30 seconds. Proceeding with forceful shutdown");
            }
        } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
        }
    }
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
public void shutdownExecutor() {
	if (executor != null && internalExecutor) {
		if (executor instanceof ThreadPoolExecutor) {
			// this is our internal one, so we need to shut it down
			ThreadPoolExecutor tpe = (ThreadPoolExecutor) executor;
			tpe.shutdownNow();
			long timeout = getExecutorTerminationTimeoutMillis();
			if (timeout > 0) {
				try {
					tpe.awaitTermination(timeout, TimeUnit.MILLISECONDS);
				} catch (InterruptedException e) {
					// Ignore
				}
				if (tpe.isTerminating()) {
					getLog().warn(
							sm.getString("endpoint.warn.executorShutdown",
									getName()));
				}
			}
			TaskQueue queue = (TaskQueue) tpe.getQueue();
			queue.setParent(null);
		}
		executor = null;
	}
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
/**
 * Start the component and implement the requirements
 * of {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
 *
 * @exception LifecycleException if this component detects a fatal error
 *  that prevents this component from being used
 */
@Override
protected void startInternal() throws LifecycleException {

    taskqueue = new TaskQueue(maxQueueSize);
    TaskThreadFactory tf = new TaskThreadFactory(namePrefix,daemon,getThreadPriority());
    executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), maxIdleTime, TimeUnit.MILLISECONDS,taskqueue, tf);
    executor.setThreadRenewalDelay(threadRenewalDelay);
    if (prestartminSpareThreads) {
        executor.prestartAllCoreThreads();
    }
    taskqueue.setParent(executor);

    setState(LifecycleState.STARTING);
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
/**
 * Updates each ThreadPoolExecutor with the current time, which is the time
 * when a context is being stopped.
 * 
 * @param context
 *            the context being stopped, used to discover all the Connectors
 *            of its parent Service.
 */
private void stopIdleThreads(Context context) {
    if (serverStopping) return;

    if (!(context instanceof StandardContext) ||
        !((StandardContext) context).getRenewThreadsWhenStoppingContext()) {
        log.debug("Not renewing threads when the context is stopping. "
            + "It is not configured to do it.");
        return;
    }

    Engine engine = (Engine) context.getParent().getParent();
    Service service = engine.getService();
    Connector[] connectors = service.findConnectors();
    if (connectors != null) {
        for (Connector connector : connectors) {
            ProtocolHandler handler = connector.getProtocolHandler();
            Executor executor = null;
            if (handler != null) {
                executor = handler.getExecutor();
            }

            if (executor instanceof ThreadPoolExecutor) {
                ThreadPoolExecutor threadPoolExecutor =
                    (ThreadPoolExecutor) executor;
                threadPoolExecutor.contextStopping();
            } else if (executor instanceof StandardThreadExecutor) {
                StandardThreadExecutor stdThreadExecutor =
                    (StandardThreadExecutor) executor;
                stdThreadExecutor.contextStopping();
            }

        }
    }
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
private static AsynchronousChannelGroup createAsynchronousChannelGroup() {
    // Need to do this with the right thread context class loader else the
    // first web app to call this will trigger a leak
    ClassLoader original = Thread.currentThread().getContextClassLoader();

    try {
        Thread.currentThread().setContextClassLoader(
                AsyncIOThreadFactory.class.getClassLoader());

        // These are the same settings as the default
        // AsynchronousChannelGroup
        int initialSize = Runtime.getRuntime().availableProcessors();
        ExecutorService executorService = new ThreadPoolExecutor(
                0,
                Integer.MAX_VALUE,
                Long.MAX_VALUE, TimeUnit.MILLISECONDS,
                new SynchronousQueue<Runnable>(),
                new AsyncIOThreadFactory());

        try {
            return AsynchronousChannelGroup.withCachedThreadPool(
                    executorService, initialSize);
        } catch (IOException e) {
            // No good reason for this to happen.
            throw new IllegalStateException(sm.getString("asyncChannelGroup.createFail"));
        }
    } finally {
        Thread.currentThread().setContextClassLoader(original);
    }
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
public void setMinSpareThreads(int minSpareThreads) {
    this.minSpareThreads = minSpareThreads;
    Executor executor = this.executor;
    if (internalExecutor && executor instanceof java.util.concurrent.ThreadPoolExecutor) {
        // The internal executor should always be an instance of
        // j.u.c.ThreadPoolExecutor but it may be null if the endpoint is
        // not running.
        // This check also avoids various threading issues.
        ((java.util.concurrent.ThreadPoolExecutor) executor).setCorePoolSize(minSpareThreads);
    }
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
public void setMaxThreads(int maxThreads) {
    this.maxThreads = maxThreads;
    Executor executor = this.executor;
    if (internalExecutor && executor instanceof java.util.concurrent.ThreadPoolExecutor) {
        // The internal executor should always be an instance of
        // j.u.c.ThreadPoolExecutor but it may be null if the endpoint is
        // not running.
        // This check also avoids various threading issues.
        ((java.util.concurrent.ThreadPoolExecutor) executor).setMaximumPoolSize(maxThreads);
    }
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
/**
 * Return the amount of threads that are managed by the pool.
 *
 * @return the amount of threads that are managed by the pool
 */
public int getCurrentThreadCount() {
    if (executor!=null) {
        if (executor instanceof ThreadPoolExecutor) {
            return ((ThreadPoolExecutor)executor).getPoolSize();
        } else if (executor instanceof ResizableExecutor) {
            return ((ResizableExecutor)executor).getPoolSize();
        } else {
            return -1;
        }
    } else {
        return -2;
    }
}
 

import org.apache.tomcat.util.threads.ThreadPoolExecutor; //导入依赖的package包/类
/**
 * Return the amount of threads that are in use
 *
 * @return the amount of threads that are in use
 */
public int getCurrentThreadsBusy() {
    if (executor!=null) {
        if (executor instanceof ThreadPoolExecutor) {
            return ((ThreadPoolExecutor)executor).getActiveCount();
        } else if (executor instanceof ResizableExecutor) {
            return ((ResizableExecutor)executor).getActiveCount();
        } else {
            return -1;
        }
    } else {
        return -2;
    }
}