From b8a9cf7b0542227c071d875925a31ff2df2b0e38 Mon Sep 17 00:00:00 2001 From: remm Date: Thu, 8 Jun 2006 15:00:12 +0000 Subject: [PATCH] - While it wouldn't be a completely bad idea to switch to an executor, the black box behavior of an executor makes it a bit bad to be used with a default lame implementation, while the fancy implementations are more "big server" ready with far more overhead and complexity. git-svn-id: https://svn.apache.org/repos/asf/tomcat/tc6.0.x/trunk@412766 13f79535-47bb-0310-9956-ffa450edef68 --- .../tomcat/util/net/SimpleThreadPoolExecutor.java | 312 --------------------- 1 file changed, 312 deletions(-) delete mode 100644 java/org/apache/tomcat/util/net/SimpleThreadPoolExecutor.java diff --git a/java/org/apache/tomcat/util/net/SimpleThreadPoolExecutor.java b/java/org/apache/tomcat/util/net/SimpleThreadPoolExecutor.java deleted file mode 100644 index f0c42ca44..000000000 --- a/java/org/apache/tomcat/util/net/SimpleThreadPoolExecutor.java +++ /dev/null @@ -1,312 +0,0 @@ -/* - * Copyright 1999-2006 The Apache Software Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.tomcat.util.net; - -import java.util.concurrent.Executor; - -public class SimpleThreadPoolExecutor implements Executor { - - - private boolean running = true; - - /** - * Available workers. - */ - protected WorkerStack workers = null; - - /** - * Current worker threads busy count. - */ - protected int curThreadsBusy = 0; - - - /** - * Current worker threads count. - */ - protected int curThreads = 0; - - - /** - * Sequence number used to generate thread names. - */ - protected int sequence = 0; - - - /** - * Maximum amount of worker threads. - */ - protected int maxThreads = 40; - public void setMaxThreads(int maxThreads) { this.maxThreads = maxThreads; } - public int getMaxThreads() { return maxThreads; } - - /** - * Name of the thread pool, which will be used for naming child threads. - */ - protected String name = "TP"; - public void setName(String name) { this.name = name; } - public String getName() { return name; } - - public int getCurrentThreadCount() { - return curThreads; - } - - public int getCurrentThreadsBusy() { - return curThreads - workers.size(); - } - - public SimpleThreadPoolExecutor(String name, int maxThreads) { - this.name = name; - this.maxThreads = maxThreads; - workers = new WorkerStack(maxThreads); - } - - public void execute(Runnable job){ - getWorkerThread().assign(job); - } - - // ----------------------------------------------------- Worker Inner Class - - - protected class Worker implements Runnable { - - protected Thread thread = null; - protected boolean available = false; - protected Runnable job = null; - - - /** - * Process an incoming TCP/IP connection on the specified socket. Any - * exception that occurs during processing must be logged and swallowed. - * NOTE: This method is called from our Connector's thread. We - * must assign it to our own thread so that multiple simultaneous - * requests can be handled. - * - * @param socket TCP socket to process - */ - synchronized void assign(Runnable job) { - - // Wait for the Processor to get the previous Socket - while (available) { - try { - wait(); - } catch (InterruptedException e) { - } - } - - // Store the newly available Socket and notify our thread - this.job = job; - available = true; - notifyAll(); - - } - - - /** - * Await a newly assigned Socket from our Connector, or null - * if we are supposed to shut down. - */ - private synchronized Runnable await() { - - // Wait for the Connector to provide a new Socket - while (!available) { - try { - wait(); - } catch (InterruptedException e) { - } - } - - // Notify the Connector that we have received this Socket - Runnable job = this.job; - available = false; - notifyAll(); - - return (job); - - } - - public void shutdown(){ - running = false; - } - - /** - * The background thread that listens for incoming TCP/IP connections and - * hands them off to an appropriate processor. - */ - public void run() { - - // Process requests until we receive a shutdown signal - while (running) { - - // Wait for the next socket to be assigned - Runnable job = await(); - if (job == null) - continue; - - job.run(); - - job = null; - - recycleWorkerThread(this); - } - - } - - - /** - * Start the background processing thread. - */ - public void start() { - thread = new Thread(this); - thread.setName(getName() + "-" + (++curThreads)); - thread.setDaemon(true); - thread.start(); - } - - - } - - - /** - * Create (or allocate) and return an available processor for use in - * processing a specific HTTP request, if possible. If the maximum - * allowed processors have already been created and are in use, return - * null instead. - */ - protected Worker createWorkerThread() { - - synchronized (workers) { - if (workers.size() > 0) { - curThreadsBusy++; - return workers.pop(); - } - if ((maxThreads > 0) && (curThreads < maxThreads)) { - curThreadsBusy++; - return (newWorkerThread()); - } else { - if (maxThreads < 0) { - curThreadsBusy++; - return (newWorkerThread()); - } else { - return (null); - } - } - } - - } - - /** - * Create and return a new processor suitable for processing HTTP - * requests and returning the corresponding responses. - */ - protected Worker newWorkerThread() { - - Worker workerThread = new Worker(); - workerThread.start(); - return (workerThread); - - } - - /** - * Return a new worker thread, and block while to worker is available. - */ - protected Worker getWorkerThread() { - // Allocate a new worker thread - Worker workerThread = createWorkerThread(); - while (workerThread == null) { - try { - synchronized (workers) { - workers.wait(); - } - } catch (InterruptedException e) { - // Ignore - } - workerThread = createWorkerThread(); - } - return workerThread; - } - - - /** - * Recycle the specified Processor so that it can be used again. - * - * @param workerThread The processor to be recycled - */ - protected void recycleWorkerThread(Worker workerThread) { - synchronized (workers) { - workers.push(workerThread); - curThreadsBusy--; - workers.notify(); - } - } - - // ------------------------------------------------- WorkerStack Inner Class - - - public class WorkerStack { - - protected Worker[] workers = null; - protected int end = 0; - - public WorkerStack(int size) { - workers = new Worker[size]; - } - - /** - * Put the object into the queue. - * - * @param object the object to be appended to the queue (first element). - */ - public void push(Worker worker) { - workers[end++] = worker; - } - - /** - * Get the first object out of the queue. Return null if the queue - * is empty. - */ - public Worker pop() { - if (end > 0) { - return workers[--end]; - } - return null; - } - - /** - * Get the first object out of the queue, Return null if the queue - * is empty. - */ - public Worker peek() { - return workers[end]; - } - - /** - * Is the queue empty? - */ - public boolean isEmpty() { - return (end == 0); - } - - /** - * How many elements are there in this queue? - */ - public int size() { - return (end); - } - } - - -} -- 2.11.0