线程池的实现

　　　组成

　　　 一个比较简单的线程池至少应包括

　　　　　　　　线程池管理器：创建、销毁并管理线程池，将工作线程放入线程池中；

　　　　　　　　工作线程：一个可以循环执行任务的线程，在没有任务时进行等待；

　　　　　　　　任务队列：提供一种缓冲机制，将没有处理的任务放在任务队列中；

　　　　　　　　任务接口：每个任务必须实现的接口，主要用来规定任务的入口、任务执行完后的收尾工作、任务的执行状态等。 工作线程通过该接口调度任务的执行。

　　　原理

　　　类似于操作系统中的缓冲区，流程如下：

　　　先启动若干数量的线程，并让这些线程都处于等待状态，当客户端有一个新请求时，就会唤醒线程池中的某一个等待线程，让他来处理客户端的这个请求，当处理完后，继续处于等待状态。

代码实现

　　　ThreadPoolManager类： 管理线程池，初始化线程池，并为客户端请求分配不同的线程来处理；

　　　SimpleThread类：Thread类的一个子类，对客户端请求进行处理的类，初始化时均为睡眠状态，若接收到ThreadPoolManager的调度，则会唤醒线程。

package thread;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;


public class threadpool {
        
    static class ThreadPoolManager{
            private int MaxThread;
            private Vector ThreadQueue;
            
            public void setMaxThread(int count){
                this.MaxThread=count;
            }
            
            public ThreadPoolManager(int count){
                setMaxThread(count);
                System.out.println("Starting Thread Pool");
                ThreadQueue=new Vector();
                for(int i=0;i<=MaxThread;i++){
                    SimpleThread thread=new SimpleThread(i);
                    ThreadQueue.addElement(thread);
                    thread.start();
                }
            }
            
            public void process(String argument){
                int i;
                for(i=0;i<ThreadQueue.size();i++){
                    SimpleThread current=(SimpleThread) ThreadQueue.elementAt(i);
                    if(!current.isRunning()){
                        System.out.println("Thread"+(i+1)+"is processing:"+argument);
                        current.setArgument(argument);
                        current.setRunning(true);
                        return;
                    }
                }
                
                if(i==ThreadQueue.size()){
                    System.out.println("pool is full,try in anthor time");
                }
            }
            
    }
    
    
    static class SimpleThread extends Thread{
        private boolean RunningFlag;
        private String argument;
        public boolean isRunning(){
            return RunningFlag;
        }
        
        public synchronized void setRunning(Boolean Flag){
            RunningFlag=Flag;
            if(Flag){
                this.notify();
            }
        }
        
        public String getArgument(){
            return this.argument;
        }
        
        public void setArgument(String string){
            argument=string;
        }
        
        public SimpleThread(int threadNumber){
            RunningFlag=false;
            System.out.println("thread"+threadNumber+"started.");
        }
        
        public synchronized void run(){
            try {
                while(true){
                    if(!RunningFlag){
                        this.wait();
                    }
                    else{
                        System.out.println("process"+getArgument()+"……done!");
                        sleep(5000);
                        System.out.println("Thread is sleeping.");
                        setRunning(false);
                        
                    }
                }
            } catch (Exception e) {
                // TODO: handle exception
                System.out.println("Interrupt");
            }
        }
    }
    
    public static void main(String[] args) {
        try {
            BufferedReader brBufferedReader=new BufferedReader(new InputStreamReader(System.in));
            String string;
            ThreadPoolManager manager=new ThreadPoolManager(10);
            while((string=brBufferedReader.readLine())!=null){
                manager.process(string);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    
    
}