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

今天突然看到这么道面试题，想了半天，也没有眉目。结果在网上到是搜出来不少，就从中找了一篇比较好的，留到自己的blog上来，以备以后用吧。代码的原创者，也不去找了，但愿哪天看到了，不要怪罪才好。

在此，再在源码的基础上加点根据自己的理解而形成的注释。

import   java.util.LinkedList;
//抽象类，命名为Manager(管理者)
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; 否则，设置线程集合为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();
        }

}
不过虽然是加了注释，也还是没有全文性地看太明白。有时间再来研究吧.