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();  
          }  
   
  }