我们大家都知道，在处理多线程服务并发时，由于创建线程需要占用很多的系统资源，所以为了避免这些不必要的损耗，通常我们采用线程池来解决这些问题。

　　线程池的基本原理是，首先创建并保持一定数量的线程，当需要使用线程时，我们从池中取得线程，再将需要运行的任务交给线程进行处理，当任务完成后再将其释放回池中。

　　下面，我给出一个很简单的实现模型，仅供参考。

　ThreadPool.java
　　package org.loon.framework.util.test;
　　import java.util.LinkedList;
　　import java.util.List;

　　public class ThreadPool ... {
　　private static ThreadPool instance = null ;
　　// 优先级低
　　public static final int PRIORITY_LOW = 0 ;
　　// 普通
　　public static final int PRIORITY_NORMAL = 1 ;
　　// 高
　　public static final int PRIORITY_HIGH = 2 ;
　　// 用以保存空闲连接
　　private List[] _idxThreads;
　　// 关闭
　　private boolean _shutdown = false ;
　　// 线程数量
　　private int _threadCount = 0 ;
　　// debug信息是否输出
　　private boolean _debug = false ;
　　/** */ /**
　　* 返回ThreadPool实例
　　*
　　* @return
　　*/
　　public static ThreadPool getInstance() ... {
　　if (instance == null ) ... {
　　instance = new ThreadPool();
　　}
　　return instance;
　　}
　　// 初始化线程list
　　private ThreadPool() ... {
　　this ._idxThreads = new List[] ... { new LinkedList(), new LinkedList(),
　　new LinkedList() } ;
　　this ._threadCount = 0 ;
　　}
　　/** */ /**
　　* 同步方法，完成任务后将资源放回线程池中
　　* @param repool
　　*/
　　protected synchronized void repool(Pooled repool) ... {
　　if ( this ._shutdown) ... {
　　if ( this ._debug) ... {
　　System.out.println( " ThreadPool.repool():重设中…… " );
　　}
　　// 优先级别判定
　　switch (repool.getPriority()) ... {
　　case Thread.MIN_PRIORITY:
　　this ._idxThreads[PRIORITY_LOW].add(repool);
　　break ;
　　case Thread.NORM_PRIORITY:
　　this ._idxThreads[PRIORITY_NORMAL].add(repool);
　　break ;
　　case Thread.MAX_PRIORITY:
　　this ._idxThreads[PRIORITY_HIGH].add(repool);
　　break ;
　　default :
　　throw new IllegalStateException( " 没有此种级别 " );
　　}
　　// 通知所有线程
　　notifyAll();
　　} else ... {
　　if ( this ._debug) ... {
　　System.out.println( " ThreadPool.repool():注销中…… " );
　　}
　　repool.shutDown();
　　}
　　if ( this ._debug) ... {
　　System.out.println( " ThreadPool.repool():完成 " );
　　}
　　}
　　public void setDebug( boolean debug) ... {
　　this ._debug = debug;
　　}
　　public synchronized void shutDown() ... {
　　this ._shutdown = true ;
　　if ( this ._debug) ... {
　　System.out.println( " ThreadPool.shutDown():关闭中…… " );
　　}
　　for ( int index = 0 ;index <= PRIORITY_NORMAL;index ++ ) ... {
　　List threads = this ._idxThreads[index];
　　for ( int threadIndex = 0 ;threadIndex < threads.size();threadIndex ++ ) ... {
　　Pooled idleThread = (Pooled)threads.get(threadIndex);
　　idleThread.shutDown();
　　}
　　}
　　notifyAll();

　   }

　　/** */ /**
　　* 以指定的优先级启动线程
　　* @param target
　　* @param priority
　　*/
　　public synchronized void start(Runnable target, int priority) ... {
　　Pooled thread = null ;
　　List idleList = this ._idxThreads[priority];
　　int idleSize = idleList.size();
　　if (idleSize > 0 ) ... {
　　int lastIndex = idleSize - 1 ;
　　thread = (Pooled)idleList.get(lastIndex);
　　idleList.remove(idleList);
　　thread.setTarget(target);
　　} else ... {
　　this ._threadCount ++ ;
　　thread = new Pooled(target, " Pooled-> " + this ._threadCount, this );
　　switch (priority) ... {
　　case PRIORITY_LOW:
　　thread.setPriority(Thread.MIN_PRIORITY);
　　break ;
　　case PRIORITY_NORMAL:
　　thread.setPriority(Thread.NORM_PRIORITY);
　　break ;
　　case PRIORITY_HIGH:
　　thread.setPriority(Thread.MAX_PRIORITY);
　　break ;
　　default :
　　thread.setPriority(Thread.NORM_PRIORITY);
　　}
　　// 启动
　　thread.start();
　　}
　　}
　　/** */ /**
　　* 返回线程数量
　　*
　　* @return
　　*/
　　public int getThreadsCount() ... {
　　return this ._threadCount;
　　}
　　}
　　Pooled.java:
　　package org.loon.framework.util.test;

　　public class Pooled extends Thread ... {
　　private ThreadPool _pool;
　　private Runnable _target;
　　private boolean _shutdown = false ;
　　private boolean _idle = false ;
　　public Pooled(Runnable target) ... {
　　super (target);
　　}
　　public Pooled(Runnable target, String name) ... {
　　super (target, name);
　　}
　　public Pooled(Runnable target, String name, ThreadPool pool) ... {
　　super (name);
　　this ._pool = pool;
　　this ._target = target;
　　}
　　public Pooled(String name) ... {
　　super (name);
　　}
　　public Pooled(ThreadGroup group, Runnable target) ... {
　　super (group, target);
　　}
　　public Pooled(ThreadGroup group, Runnable target, String name) ... {
　　super (group, target, name);
　　}
　　public Pooled(ThreadGroup group, String name) ... {
　　super (group, name);
　　}
　　public Runnable getTarget() ... {
　　return this ._target;
　　}
　　public boolean isIdle() ... {
　　return this ._idle;
　　}
　　public void run() ... {
　　while ( ! this ._shutdown) ... {
　　this ._idle = false ;
　　if ( this ._target != null ) ... {
　　this ._target.run();
　　}
　　this ._idle = true ;
　　try ... {
　　this ._pool.repool( this );
　　synchronized ( this ) ... {
　　wait();
　　}
　　} catch (InterruptedException ex) ... {
　　System.err.println(ex.getMessage());
　　}
　　this ._idle = false ;
　　}
　　}
　　public synchronized void setTarget(Runnable target) ... {
　　this ._target = target;
　　notifyAll();
　　}
　　public synchronized void shutDown() ... {
　　this ._shutdown = true ;
　　notifyAll();
　　}
　　}

　　测试用类：
　
　package org.loon.framework.util.test;

　　public class ThreadPoolTest ... {
　　private static Runnable createRunnable( final int id) ... {
　　return new Runnable() ... {
　　public void run() ... {
　　System.out.println( " 线程 " + id + " ,运行 " );
　　try ... {
　　Thread.sleep( 1000 );
　　}
　　catch (InterruptedException ex) ... { }
　　System.out.println( " 线程 " + id + " ,结束 " );
　　}
　　} ;
　　}
　　public static void main(String[]args) ... {
　　ThreadPool pool = ThreadPool.getInstance();
　　pool.setDebug( true );
　　for ( int i = 1 ; i <= 10 ; i ++ ) ... {
　　// 根据数值，设定不同优先级
　　if (i % 2 == 0 ) ... {
　　pool.start(createRunnable(i), ThreadPool.PRIORITY_HIGH);
　　} else ... {
　　pool.start(createRunnable(i), ThreadPool.PRIORITY_LOW);
　　}
　　}
　　System.out.println( " 线程池测试中…… " );
　　System.out.println( " 线程池线程总数: " + pool.getThreadsCount());
　　pool.shutDown();
　　}
　　}