A simple thread pool implementation

java 代码

import java.util.Vector;

/**
 * Thread pool
 */
public class ThreadPool implements Runnable {

    // Default ThreadPool minimum size
    public final static int DEFAULT_MIN_SIZE = 0;

    // Default ThreadPool maximum size
    public final static int DEFAULT_MAX_SIZE = Integer.MAX_VALUE;

    public final static long DEFAULT_RELEASE_DELAY = 10 * 1000;

    // customized thread pool minimum size
    protected int minSize;

    // customized thread pool maximum size
    protected int maxSize;

    protected long releaseDelay;

    // current threads size in threadpool
    protected int currentSize;

    protected int availableThreads;

    // task list
    protected Vector taskList;

    /**
     * customized ThradPool
     *
     * @param minSize
     *            minimum thread pool size
     * @param maxSize
     *            maximum thread pool size
     * @param releaseDelay
     *            threads release delay
     */
    public ThreadPool(int minSize, int maxSize, long releaseDelay) {
        this.minSize = minSize;
        this.maxSize = maxSize;
        this.releaseDelay = releaseDelay;
        taskList = new Vector(100);
        availableThreads = 0;
    }

    /**
     * Default ThreadPool
     */
    public ThreadPool() {
        this(DEFAULT_MIN_SIZE, DEFAULT_MIN_SIZE, DEFAULT_RELEASE_DELAY);
    }

    /**
     * set minimum thread pool size
     *
     * @param minSize
     *            minimum thread pool size
     */
    public synchronized void setMinSize(int minSize) {
        this.minSize = minSize;
    }

    /**
     * get minimum thread pool size
     */
    public synchronized int getMinSize() {
        return minSize;
    }

    /**
     * set maximum thread pool size
     *
     * @param maxSize
     *            maximum thread pool size
     */
    public synchronized void setMaxSize(int maxSize) {
        this.maxSize = maxSize;
    }

    /**
     * get maximum thread pool size
     */
    public synchronized int getMaxSize() {
        return maxSize;
    }

    /**
     * set thread release delay
     *
     * @param releaseDelay
     *            thread release delay time
     */
    public synchronized void setReleaseDelay(long releaseDelay) {
        this.releaseDelay = releaseDelay;
    }

    /**
     * get thread release delay
     */
    public synchronized long getReleaseDelay() {
        return releaseDelay;
    }

    /**
     * add a task to task list of ThreadPool
     *
     * @param runnable
     *            new task
     */
    public synchronized void addTask(Runnable runnable) {

        taskList.addElement(runnable);
        if (availableThreads > 0) {
            this.notify();
        } else {
            if (currentSize < maxSize) {
                Thread t = new Thread(this);
                currentSize++;
                t.start();
            }
        }
    }

    public void run() {
        Runnable task;
        while (true) {
            synchronized (this) {
                if (currentSize > maxSize) {
                    currentSize--;
                    break;
                }
                task = getNextTask();
                if (task == null) {
                    try {
                        availableThreads++;
                        wait(releaseDelay);
                        availableThreads--;
                    } catch (InterruptedException ie) {
                        // do something you wanna
                    }
                    task = getNextTask();
                    if (task == null) {
                        if (currentSize < minSize)
                            continue;
                        currentSize--;
                        break;
                    }
                }
            }
            try {
                task.run();
            } catch (Exception e) {
                System.err.println("Uncaught exception");
                e.printStackTrace(System.err);
            }
        }
    }

    /**
     * get the next task from task list.
     *
     */
    protected synchronized Runnable getNextTask() {
        Runnable task = null;
        if (taskList.size() > 0) {
            task = (Runnable) (taskList.elementAt(0));
            taskList.removeElementAt(0);
        }
        return task;
    }

    /**
     * return thread pool message
     */
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("DEFAULT_MIN_SIZE : " + DEFAULT_MIN_SIZE + "\n");
        sb.append("DEFAULT_MAX_SIZE : " + DEFAULT_MAX_SIZE + "\n");
        sb.append("DEFAULT_RELEASE_DELAY : " + DEFAULT_RELEASE_DELAY + "\n");
        sb.append("the information about your's construct ThreadPool below : \n");
        sb.append("minSize \t maxSize \t releaseDelay \n");
        sb.append(minSize + "\t" + maxSize + "\t" + releaseDelay);

        return sb.toString();
    }

}

分享到：

E=MC2 | A useful MultiSemaphore

• 2007-03-07 11:53
• 浏览 1051
• 评论(0)
• 查看更多