一个java程序实现线程连接池功能

import   java.util.LinkedList; 
  
  public   abstract   class   Manager   { 
  
          private   String   mThreadPoolName   =   null; 
  
          private   int   mThreadPoolMaxSize   =   1; 
  
          private   LinkedList   workers   =   new   LinkedList(); 
  
          public   Manager()   { 
          } 
  
          public   Manager(String   name,   int   poolMaxSize)   { 
                  mThreadPoolName   =   name; 
                  createWorker(name,   poolMaxSize); 
                  mThreadPoolMaxSize   =   poolMaxSize; 
          } 
  
          private   void   createWorker(int   poolMaxSize)   { 
                          for   (int   i   =   0;   i   <   poolMaxSize;   i++)   { 
                                  Worker   worker   =   new   ...Worker(this); 
                                  workers.addLast(worker); 
                          } 
          } 
  
          public   synchronized   Worker   getIdleWorker()   { 
                  return   (Worker)workers.removeFirst(); 
          } 
  
          public   synchronized   void   notifyFree(Worker   worker)   { 
                  if   (workers.size()   <   mThreadPoolMaxSize)   { 
                          workers.addLast(worker); 
                  }   else   { 
                          worker   =   null; 
                  } 
          } 
  
          public   int   getThreadPoolMaxSize()   { 
                  return   mThreadPoolMaxSize; 
          } 
  
          public   void   setThreadPoolMaxSize(int   threadPoolMaxSize)   { 
                  this.mThreadPoolMaxSize   =   threadPoolMaxSize; 
          } 
  
  } 
  
  线程抽象类 
  
  public   abstract   class   Worker   implements   Runnable   { 
  
          private   Manager   mManager   =   null; 
  
          private   Thread   mThread   =   null; 
      
          public   Worker()   { 
          } 
  
          public   Worker(String   threadName,   Manager   manager)   { 
                  mManager   =   manager; 
                  mThread   =   new   Thread(this,   threadName); 
                  init(); 
                  mThread.start(); 
          } 
  
          public   abstract   void   init(); 
  
          public   void   run()   { 
                  while   (true)   { 
                          waitForStart(); 
                          Worker   worker   =   mManager.getIdleWorker(); 
                          process(); 
                          isRunning   =   false; 
                          mManager.notifyFree(worker); 
                  } 
          } 
  
          public   abstract   void   process(); 
  
          public   void   start()   { 
                  isRunning   =   true; 
                  mManager.getIdleWorker(); 
                  notifyToStart(); 
          } 
  
          public   synchronized   void   waitForStart()   { 
                  try   { 
                          wait(); 
                  }   catch   (InterruptedException   ex)   { 
                  } 
          } 
  
          public   synchronized   void   notifyToStart()   { 
                  notify(); 
          } 
  
  } 
转http://www.itzhuyi.com/Item/Show.asp?d=10268&m=1