基于线程池的http服务器

     前端时间，用线程池做了一个http服务器，专门处理get请求，基于socket编程，主要是自己想对操作系统级的编程比较感兴趣。好了，贴出代码，供大家参考：

    

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try{
			
			ServerSocket server = new ServerSocket(8000);
			System.out.println("Server is listenning");

			ThreadPoolManager manager = new ThreadPoolManager(3);
			int  i = 0;
			while(true){
				
				Socket client = server.accept();
				manager.add(client);
				i++;
				System.out.println(i);
			
			}


		}catch(IOException e){
			e.printStackTrace();
		}
	}

  这是整个程序的入口，初始化该初始化的，监听该

监听的。ThreadPoolManager用于管理线程，初始化有三个线程。

     accept方法会造成阻塞，知道有消息传过来。将接收到的消息传入到manager中以便于管理。

   

 

 

public class ThreadPoolManager {
	private int maxThread;
	public Vector vector;
	public Queue buffer;
	public void setMaxThread(int maxThread) {
		this.maxThread = maxThread;
	}
	public int getMaxThread() {
		return maxThread;
	}
	
	public ThreadPoolManager(int threadCount){
		this.setMaxThread(threadCount);
		buffer = new ArrayBlockingQueue(100);
		System.out.println("Starting pool");
		vector = new Vector();
		for(int i=1;i<=threadCount;i++){
			SimpleThreak st = new SimpleThreak(i,buffer);
			vector.add(st);
			st.start();
		}
			
	}
	
	public void add(Socket client){
		synchronized (buffer) {
			buffer.offer(client);
			buffer.notify();
		}
		
		
	}
	

 

      线程池类，线程池在初始化之后放入一个vector之中，同时将请求放入一个缓冲区中，缓冲区用 ArrayBlockingQueue来做。

      BlockingQueue接口定义了一种阻塞的FIFO queue，每一个BlockingQueue都有一个容量，让容量满时往BlockingQueue中添加数据时会造成阻塞，当容量为空时取元素操作会阻塞。ArrayBlockingQueue是对BlockingQueue的一个数组实现，它使用一把全局的锁并行对queue的读写操作，同时使用两个Condition阻塞容量为空时的取操作和容量满时的写操作。

 

    

	public synchronized void run(){
		try{
			
			while(true){
					    	synchronized (buffer) {
					    		
								if(buffer.isEmpty()){
									buffer.wait();
								}
								
								this.client = buffer.poll();
								System.out.println(this.number+"------running");
				    	
					    	}
			
				    		PrintStream outStream;
				    		BufferedReader in ;
							try {
								in = new BufferedReader(new InputStreamReader(client.getInputStream()));
								outStream = new PrintStream(new BufferedOutputStream(client.getOutputStream()));
								this.argument=in.readLine();
		
								if(getRequest(this.argument)){
									String fileName = getFileName(this.argument);
									File file = new File(fileName);
									if(file.exists()){
		
											sendFile(outStream,file);
										
									}else 
										System.out.println("不存在图片");
								}
								in.close();
							} catch (IOException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
					
							sleep(3*1000);
							//System.out.println("Thread is sleeping");
						
					}
			
		}catch(InterruptedException e){
			System.out.println("Interrupt");
		}
	}

   不断监视缓冲区中的动向，如果有了数据，就从缓冲区中取出socket，否则进入等待列，将socket封装到bufferReader中，取出请求的报文头，如果请求的文件存在，就将文件放入PrintStream中，送入客户端。为了看出效果，让线程工作完之后睡3秒钟。

  

 

   

	private String getFileName(String s){
		String f = s.substring(s.indexOf(' ')+1);
		f=f.substring(0,f.indexOf(' '));
		try{
			if(f.charAt(0)=='/')
				f=f.substring(1);
			
		}catch(StringIndexOutOfBoundsException e){
			e.printStackTrace();
		}
		
		if(f.equals("")) f = "index.html";
		return f;
		
	}

     通过截取报文头，来获取请求文件的位置。

 

 

 

	private void sendFile(PrintStream ps,File file){
		try{
			DataInputStream ds = new DataInputStream(new FileInputStream(file));
			int len = (int) file.length();
			//System.out.println(len);
			byte buf[]=new byte[len];
			ds.readFully(buf);
			ps.write(okResponse().getBytes());
			ps.write(buf,0,len);
			
			ps.flush();
			
			ds.close();
		}catch(Exception e){
			e.printStackTrace();
		}
	}

     将流传输到客户端的过程，先将数据写入到一个字节流中，输入到客户端。

  

     这样，一个简单的http服务器就完成了，服务器还有一个问题，就是请求过来之后会阻塞。从高人处得知，可以用nio这种非阻塞的io进行优化。正在研究之中。