使用common-pool实现的一个简单的线程池

使用apache的commons-pool完成了一个简单的可伸缩的线程池，实现的功能为： 
1、可以为线程池设定最大线程数，当有请求的时候，从池从取出一个线程来进行处理，当处理完成后，再将线程重新放入到池中。如果池中的线程不够地话，系统会自动地增加池中线程的数量，但总量不超过最大线程数。 
2、定时查看线程池，当线程池中的线程过长时间未被使用，则自动销毁它。 

MyPoolableObjectFactory.java

package org.apache.commons.amylh;
/**
* 创建销毁线程池中对象的工厂                                                  
* @author Amylh           
*/
import org.apache.commons.pool.PoolableObjectFactory;
public class MyPoolableObjectFactory
implements PoolableObjectFactory
{
private boolean isDebug = true;
public Object makeObject() throws Exception
{
SimpleThread simpleThread = new SimpleThread();
simpleThread.start();
debug("创建线程:" + simpleThread.getName());
return simpleThread;
}
public void destroyObject(Object obj) throws Exception
{
if (obj instanceof SimpleThread)
{
SimpleThread simpleThread = (SimpleThread) obj;
debug("销毁线程:" + simpleThread.getName());
simpleThread.destroy();
}
}
public boolean validateObject(Object obj)
{
return true;
}
public void activateObject(Object obj) throws Exception
{
}
public void passivateObject(Object obj) throws Exception
{
}
public void setIsDebug(boolean isDebug)
{
this.isDebug = isDebug;
}
public boolean getIsDebug()
{
return isDebug;
}
private void debug(String debugInfo)
{
if (isDebug)
{
System.out.println(debugInfo);
}
}
}

SimpleThread.java

package org.apache.commons.amylh;
/**
* 一个简单的线程                                                  
* @author Amylh           
*/
import org.apache.commons.pool.impl.*;
class SimpleThread
extends Thread
{
private boolean isRunning;
private GenericObjectPool pool;
public boolean getIsRunning()
{
return isRunning;
}
public synchronized void setIsRunning(boolean flag)
{
isRunning = flag;
if (flag)
{
this.notify();
}
}
public void setPool(GenericObjectPool pool)
{
this.pool = pool;
}
public SimpleThread()
{
isRunning = false;
}
public void destroy()
{
System.out.println("destroy中");
this.interrupt();
}
public synchronized void run()
{
try
{
while (true)
{
if (!isRunning)
{
this.wait();
}
else
{
System.out.println(this.getName() + "开始处理");
sleep(5000);
System.out.println(this.getName() + "结束处理");
setIsRunning(false);
try
{
pool.returnObject(this);
}
catch (Exception ex)
{
System.out.println(ex);
}
}
}
}
catch (InterruptedException e)
{
System.out.println("我被Interrupted了，所以此线程将被关闭");
return;
}
}
}

TestThreadPool.java

package org.apache.commons.amylh;
/**
* 此线程池的测试类                                                
* @author Amylh           
*/
import org.apache.commons.pool.impl.GenericObjectPool;
public class TestThreadPool
{
public static void main(String[] args)
{
MyPoolableObjectFactory factory = new MyPoolableObjectFactory();
GenericObjectPool pool = new GenericObjectPool(factory);
pool.setMaxActive(20); //能从池中借出的对象的最大数目
pool.setMaxIdle(20); //池中可以空闲对象的最大数目
pool.setMaxWait(100); //对象池空时调用borrowObject方法，最多等待多少毫秒
pool.setTimeBetweenEvictionRunsMillis(600000);//间隔每过多少毫秒进行一次后台对象清理的行动
pool.setNumTestsPerEvictionRun( -1);//－1表示清理时检查所有线程
pool.setMinEvictableIdleTimeMillis(3000);//设定在进行后台对象清理时，休眠时间超过了3000毫秒的对象为过期
for (int i = 0; i < 20; i++)
{
try
{
SimpleThread simpleThread = (SimpleThread) pool.borrowObject();
simpleThread.setPool(pool);
simpleThread.setIsRunning(true);
}
catch (Exception ex)
{
System.out.println(ex);
}
}
try
{
Thread.sleep(8000); //休息一会儿，再使用线程池
}
catch (InterruptedException ex1)
{
}
for (int i = 0; i < 10; i++)
{
try
{
SimpleThread simpleThread = (SimpleThread) pool.borrowObject();
simpleThread.setPool(pool);
simpleThread.setIsRunning(true);
}
catch (Exception ex)
{
System.out.println(ex);
}
}
}
}