线程池示例代码，请大家多指教

commmons pool的接口定义大致分两块,如下:

/*
 * @author Rodney Waldhoff
 * @author Sandy McArthur
 * @version $Revision: 777748 $ $Date: 2009-05-23 08:00:44 +0800 $
 * @since Pool 1.0
 */

// pool本身接口
public abstract class BaseKeyedObjectPool implements KeyedObjectPool {
    public abstract Object borrowObject(Object key) throws Exception;
    public abstract void returnObject(Object key, Object obj) throws Exception;
    public abstract void invalidateObject(Object key, Object obj) throws Exception;
    public void addObject(Object key) throws Exception, UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }
    public int getNumIdle(Object key) throws UnsupportedOperationException {
        return -1;
    }
    public int getNumActive(Object key) throws UnsupportedOperationException {
        return -1;
    }  
    public int getNumIdle() throws UnsupportedOperationException {
        return -1;
    }
    public int getNumActive() throws UnsupportedOperationException {
        return -1;
    }
    public void clear() throws Exception, UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }   
    public void clear(Object key) throws Exception, UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }   
    public void close() throws Exception {
        closed = true;
    }   
    public void setFactory(KeyedPoolableObjectFactory factory) throws IllegalStateException, UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }   
    protected final boolean isClosed() {
        return closed;
    }   
    protected final void assertOpen() throws IllegalStateException {
        if(isClosed()) {
            throw new IllegalStateException("Pool not open");
        }
    }
    private volatile boolean closed = false;
}


/*
 * @author Rodney Waldhoff
 * @version $Revision: 791907 $ $Date: 2009-07-08 00:56:33 +0800 $
 * @since Pool 1.0
 */

// pool factory接口
public abstract class BaseKeyedPoolableObjectFactory implements KeyedPoolableObjectFactory {
    /**
     * Create an instance that can be served by the pool.
     *
     * @param key the key used when constructing the object
     * @return an instance that can be served by the pool
     */
    public abstract Object makeObject(Object key)
        throws Exception;

    /**
     * Destroy an instance no longer needed by the pool.
     * <p>
     * The default implementation is a no-op.
     * </p>
     *
     * @param key the key used when selecting the instance
     * @param obj the instance to be destroyed
     */
    public void destroyObject(Object key, Object obj)
        throws Exception {
    }

    /**
     * Ensures that the instance is safe to be returned by the pool.
     * <p>
     * The default implementation always returns <tt>true</tt>.
     * </p>
     *
     * @param key the key used when selecting the object
     * @param obj the instance to be validated
     * @return always <code>true</code> in the default implementation
     */ 
    public boolean validateObject(Object key, Object obj) {
        return true;
    }

    /**
     * Reinitialize an instance to be returned by the pool.
     * <p>
     * The default implementation is a no-op.
     * </p>
     *
     * @param key the key used when selecting the object
     * @param obj the instance to be activated
     */
    public void activateObject(Object key, Object obj)
        throws Exception {
    }

    /**
     * Uninitialize an instance to be returned to the idle object pool.
     * <p>
     * The default implementation is a no-op.
     * </p>
     *
     * @param key the key used when selecting the object
     * @param obj the instance to be passivated
     */
    public void passivateObject(Object key, Object obj)
        throws Exception {
    }
}

对factory看得不是很明白....

建议楼主先去看看1.5里面Doug Lea先生写的ThreadPoolExecutor类的源码，然后再决定自己是否应该再写一个线程池。你现在虽然写的很容易，却有可能会给后来的人维护造成很大的困难！

1、

从上图可以看出：线程池的工作线程总数应该等于业务平均完成时间内的请求总数
2、

从上图可以看出：随着请求频率的变大，线程池的工作线程总数也越来越大
3、

综合分析：1、请求频率超高的情况，通过增加工作线程数是满足不了，因为每个系统都
有个最优线程总数，超过这个线程总数，多线程就没多大意义了。
2、请求频率超高的情况，只能降低请求频率，依据公式【请求频率=业务平均完成时间
内的请求个数/业务平均完成时间】，我们只能降低业务平均完成时间，估计得通过硬件
来解决吧

LZ,还在用1.4.换成1.5吧，直接Executor类

LZ 我觉得你可以转变一种思路 不要任务/请求 去驱动线程 哪里有一个请求就一个线程的说法
我觉得可以反过来  用线程去做任务  如果你有空闲的线程 那么就让这些线程去跑业务 如果没有 任务就放到队列里面 让它等着 直到它超时 或被调用.

需要的时候去pool中拿thread对象,做完业务后,再放回pool...
如果线程数达到maxSleeping阀值,让业务等待..
我觉得没必要在init的时候就让thread start

没事不要搞这种底层组件的山寨轮子，真的。

public class ThreadPool {   
    private int threadCount; //线程总个数   
    private int GetIdleThreadPollTime=50;//获取空闲线程轮询间隔时间,可配置   
    private static ThreadPool pool=new ThreadPool();//线程实例     
    private List threadlist=new ArrayList();//工作线程列表   
    private TaskMonitorThread mainThread;//任务监测线程   
    private boolean StopGetIdleThread=false;   
    //单例模式   
    private ThreadPool(){   
    }      
    public static  ThreadPool getInstance(){   
        return pool;   
    }   
}

这段代码很好 ！

wahahah
public synchronized void init(int count){   
        System.out.println("开始初始化线程池...");   
        this.threadCount=count;   
        for(int i=0;i<count;i++){   
            WorkThread t=new WorkThread(new Integer(i));   
            threadlist.add(t);   
            t.start();   
        }  

LZ想挑战Doug Lea