public class ReusableThread implements Runnable {
 //線程狀態(tài)監(jiān)聽者接口
 public interface ThreadStateListener {
  public abstract void onRunOver(ReusableThread thread);//當用戶過程執(zhí)行完畢后調用的方法
 }
 
 public static final byte STATE_READY=0; //線程已準備好，等待開始用戶過程
 public static final byte STATE_STARTED=1; //用戶過程已啟動
 public static final byte STATE_DESTROYED=2; //線程最終銷毀
 
 byte mState; //標示可重啟線程的當前狀態(tài)
 
 Thread mThread; //實際的主線程對象
 Runnable mProc; //用戶過程的run()方法定義在mProc中
 ThreadStateListener mListener; //狀態(tài)監(jiān)聽者，可以為null
 
 /** Creates a new instance of ReusableThread */
 public ReusableThread(Runnable proc) {
  mProc = proc;
  mListener = null;
  mThread = new Thread(this);
  mState = STATE_READY;
 }
 
 public byte getState() {return mState;}
 
 public void setStateListener(ThreadStateListener listener) {
  mListener = listener;
 }
 
 /**可以在處于等待狀態(tài)時調用該方法重設用戶過程*/
 public synchronized boolean setProcedure(Runnable proc) {
  if (mState == STATE_READY) {
   mProc = proc;
   return true;
  }
  else
   return false;
 }
 
 /**開始執(zhí)行用戶過程*/
 public synchronized boolean start() {
  if (mState == STATE_READY) {
   mState = STATE_STARTED;
   if (!mThread.isAlive()) mThread.start();
   notify(); //喚醒因用戶過程執(zhí)行結束而進入等待中的主線程
   return true;
  }
  else
   return false;
 }
 
 /**結束整個線程，銷毀主線程對象。之后將不可再次啟動*/
 public synchronized void destroy() {
  mState = STATE_DESTROYED;
  notify();
  mThread = null;
 }
 
 public void run() {
  while (true) {
   synchronized (this) {
    try {
     while (mState != STATE_STARTED) {
      if (mState == STATE_DESTROYED) return;
      wait();
     }
    } catch(Exception e) {e.printStackTrace();}
   }
   
   if (mProc != null) mProc.run();
   if (mListener != null) mListener.onRunOver(this); //當用戶過程結束后，執(zhí)行監(jiān)聽者的onRunOver方法
   
   synchronized (this) {
    if (mState == STATE_DESTROYED) return;
    mState = STATE_READY;
   }
  }
 }
 
}

public class ThreadPool extends ObjectPool implements ReusableThread.ThreadStateListener {
 public static final int DefaultNumThreads = 16; //默認池容量
 
 public ReusableThread getThread() {
  return (ReusableThread)fetch();
 }
 
 public void onRunOver(ReusableThread thread) {
  recycle(thread); //當用戶過程結束時，回收線程
 }
 
 private void init(int size) {
  ReusableThread thread;
  //初始化線程池內容
  for (int i=0; i<size; i++) {
   thread = new ReusableThread(null);
   thread.setStateListener(this);
   setElementAt(thread, i);
  }
 }
 
 public ThreadPool(int size) {
  super(size);
  init(size);
 }
 
 public ThreadPool() {
  super(DefaultNumThreads);
  init(DefaultNumThreads);
 }
 
}

/**字符放射器*/
class CharEmitter implements Runnable, ReusableThread.ThreadStateListener {
 char c; //被發(fā)射的字符
 boolean[] isEmitting; //標示某字符是否正被發(fā)射（直接以字符對應的ASCII碼作下標索引）

 ReusableThread thread; //可重啟線程對象

 ObjectPool myHomePool; //為知道應把自己回收到哪里，需要保存一個到自己所在對象池的引用

 CharEmitter(ObjectPool container, boolean[] isCharEmitting) {
  isEmitting=isCharEmitting;
  myHomePool=container;
  thread=new ReusableThread(this); //新建可重啟線程對象，設其用戶過程為CharEmitter類自己定義的
 }

 /**開始“發(fā)射”字符*/
 public void emit(char ch) {
  //字符被要求只能是'0'到'9'之間的數(shù)字字符
  if (ch>='0' && ch<='9') {
   c=ch;
  }
  else c=' ';
 
  thread.start(); //啟動線程
 }

 public void run() {
  if (c==' ') return; //若不是數(shù)字字符直接結束
  //為便于觀察，不同數(shù)字之前的空格數(shù)目不同，以便將其排在不同列上
  int spaceLen=c-'0';
  StringBuffer s=new StringBuffer(spaceLen+1);
  for (int i=0; i<spaceLen; i++) s.append(' ');
  s.append(c);
 
  while (isEmitting[c]) {
    System.out.println(s); //不斷地向屏幕寫字符
  }
 }

/**實現(xiàn)線程狀態(tài)監(jiān)聽者接口中的方法*/
 public void onRunOver(ReusableThread t) {
  myHomePool.recycle(this); //回收自身入池
 }
}



public class TestThreadPool {

public static void main(String[] args) {
 // TODO Auto-generated method stub
 //標示字符是否正被發(fā)射的標志變量數(shù)組
 boolean[] isEmitting=new boolean[256];
 for (int i=0; i<256; i++) isEmitting[i]=false;
 
 ObjectPool emitters=new ObjectPool(10); //新建對象池，容量為10
 for (int i=0; i<10; i++) {
 //用CharEmitter對象填滿池子
 emitters.setElementAt(new CharEmitter(emitters, isEmitting), i);
 }
 
 byte[] c=new byte[1];
 CharEmitter emitter;
 
 while(true) {
 try {
 System.in.read(c); //從鍵盤讀入一個字符，以回車鍵表示輸入結束
 } catch(Exception e) {e.printStackTrace();}
 
 if (isEmitting[c[0]]) {
 isEmitting[c[0]]=false; //若字符正被發(fā)射，則結束其發(fā)射
 }
 else {
 isEmitting[c[0]]=true;
 emitter=(CharEmitter)emitters.fetch(); //向池中索取一個CharEmitter對象
 emitter.emit((char)c[0]); //發(fā)射用戶輸入的字符
 }
 }
}

}