src/org/apache/axis/components/threadpool/ThreadPool.java

/*
 * Copyright 2001-2004 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.axis.components.threadpool;

import org.apache.axis.components.logger.LogFactory;
import org.apache.axis.i18n.Messages;
import org.apache.commons.logging.Log;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;

/**
 * @author James M Snell (jasnell@us.ibm.com)
 */
public class ThreadPool {

    protected static Log log =
        LogFactory.getLog(ThreadPool.class.getName());

    public static final int DEFAULT_MAX_THREADS = 100;
    
    protected Map threads = new Hashtable();
    protected long threadcount;
    public boolean _shutdown;
    private int maxPoolSize = DEFAULT_MAX_THREADS;

    public ThreadPool() {
    }

    public ThreadPool(int maxPoolSize) {
        this.maxPoolSize = maxPoolSize;
    }

    public void cleanup()
        throws InterruptedException {
        if (log.isDebugEnabled()) {
            log.debug("Enter: ThreadPool::cleanup");
        }
        if (!isShutdown()) {
          safeShutdown();
          awaitShutdown();
        }
        synchronized(this) {
          threads.clear();
          _shutdown = false;
        }
        if (log.isDebugEnabled()) {
            log.debug("Exit: ThreadPool::cleanup");
        }
    }

    /**
     * Returns true if all workers have been shutdown
     */
    public boolean isShutdown() {
        synchronized (this) {
            return _shutdown && threadcount == 0;
        }
    }

    /**
     * Returns true if all workers are in the process of shutting down
     */
    public boolean isShuttingDown() {
        synchronized (this) {
            return _shutdown;
        }
    }

    /**
     * Returns the total number of currently active workers
     */
    public long getWorkerCount() {
        synchronized (this) {
            return threadcount;
        }
    }

    /**
     * Adds a new worker to the pool
     */
    public void addWorker(
            Runnable worker) {
        if (log.isDebugEnabled()) {
            log.debug("Enter: ThreadPool::addWorker");
        }
        if (_shutdown || threadcount == maxPoolSize) {
            throw new IllegalStateException(Messages.getMessage("illegalStateException00"));
        }
        Thread thread = new Thread(worker);
        threads.put(worker, thread);
        threadcount++;
        thread.start();
        if (log.isDebugEnabled()) {
            log.debug("Exit: ThreadPool::addWorker");
        }
    }

    /**
     * Forcefully interrupt all workers
     */
    public void interruptAll() {
        if (log.isDebugEnabled()) {
            log.debug("Enter: ThreadPool::interruptAll");
        }
        synchronized (threads) {
            for (Iterator i = threads.values().iterator(); i.hasNext();) {
                Thread t = (Thread) i.next();
                t.interrupt();
            }
        }
        if (log.isDebugEnabled()) {
            log.debug("Exit: ThreadPool::interruptAll");
        }
    }

    /**
     * Forcefully shutdown the pool
     */
    public void shutdown() {
        if (log.isDebugEnabled()) {
            log.debug("Enter: ThreadPool::shutdown");
        }
        synchronized (this) {
            _shutdown = true;
        }
        interruptAll();
        if (log.isDebugEnabled()) {
            log.debug("Exit: ThreadPool::shutdown");
        }
    }

    /**
     * Forcefully shutdown the pool
     */
    public void safeShutdown() {
        if (log.isDebugEnabled()) {
            log.debug("Enter: ThreadPool::safeShutdown");
        }
        synchronized (this) {
            _shutdown = true;
        }
        if (log.isDebugEnabled()) {
            log.debug("Exit: ThreadPool::safeShutdown");
        }
    }

    /**
     * Await shutdown of the worker
     */
    public synchronized void awaitShutdown()
            throws InterruptedException {
        if (log.isDebugEnabled()) {
            log.debug("Enter: ThreadPool::awaitShutdown");
        }
        if (!_shutdown)
            throw new IllegalStateException(Messages.getMessage("illegalStateException00"));
        while (threadcount > 0)
            wait();
        if (log.isDebugEnabled()) {
            log.debug("Exit: ThreadPool::awaitShutdown");
        }
    }

    /**
     * Await shutdown of the worker
     */
    public synchronized boolean awaitShutdown(long timeout)
            throws InterruptedException {
        if (log.isDebugEnabled()) {
            log.debug("Enter: ThreadPool::awaitShutdown");
        }
        if (!_shutdown)
            throw new IllegalStateException(Messages.getMessage("illegalStateException00"));
        if (threadcount == 0) {
            if (log.isDebugEnabled()) {
                log.debug("Exit: ThreadPool::awaitShutdown");
            }
            return true;
        }
        long waittime = timeout;
        if (waittime <= 0) {
            if (log.isDebugEnabled()) {
                log.debug("Exit: ThreadPool::awaitShutdown");
            }
            return false;
        }
        for (; ;) {
            wait(waittime);
            if (threadcount == 0) {
                if (log.isDebugEnabled()) {
                    log.debug("Exit: ThreadPool::awaitShutdown");
                }
                return true;
            }
            waittime = timeout - System.currentTimeMillis();
            if (waittime <= 0) {
                if (log.isDebugEnabled()) {
                    log.debug("Exit: ThreadPool::awaitShutdown");
                }
                return false;
            }
        }
    }

    /**
     * Used by MessageWorkers to notify the pool that it is done
     */
    public void workerDone(
            Runnable worker, 
            boolean restart) {
        if (log.isDebugEnabled()) {
            log.debug("Enter: ThreadPool::workerDone");
        }
        synchronized(this) {
            threads.remove(worker);
            if (--threadcount == 0 && _shutdown) {
                notifyAll();
            }
            if (!_shutdown && restart) {
                addWorker(worker);
            }
        }
        if (log.isDebugEnabled()) {
            log.debug("Exit: ThreadPool::workerDone");
        }        
    }
}