阻塞IO的理解

         一般阻塞IO通信的服务端，通常有一个独立的Acceptor线程负责监听客户端连接，它接收到客户端连接请求之后为每一个客户端分配一个新的线程来进行处理，处理完成后，通过输出流返回应答给客户端，线程才销毁。

         来看一下阻塞IO服务器的代码：

         服务器启动类

package com.bio.demo.Server;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import com.bio.demo.Server.handler.TimerServerHandler;

/**
 * @author zhouxuejun
 *
 * @date 2014年10月20日 下午7:08:58
 */
public class TimeServer {
	
     public static ServerSocket server=null;
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			server=new ServerSocket(8080);
			Socket socket=null;
			while(true){
				socket=server.accept();
				new Thread(new TimerServerHandler(socket)).start();
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
       
	}

}

处理线程类：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * @author zhouxuejun
 *
 * @date 2014年10月20日 下午7:17:28
 */
public class TimerServerHandler implements Runnable {

	 private Socket socket;
	 public  TimerServerHandler(Socket socket) {
		// TODO Auto-generated constructor stub
		 this.socket=socket;
	}
	/* (non-Javadoc)
	 * @see java.lang.Runnable#run()
	 */
	@Override
	public void run() {
		// TODO Auto-generated method stub
      BufferedReader in=null;
      PrintWriter out=null;
      try {
		in=new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
		out=new PrintWriter(this.socket.getOutputStream());
		String body=null;
		String tag=null;
		while(true){
		body=in.readLine();
		if(null==body)
			 break;
        out.print(body+"_return"); 
		}
	} catch (IOException e) {
		// TODO Auto-generated catch block
		if(null!=in){
			try {
				in.close();
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		}
		if(null!=out){
			out.close();
			out=null;
		}
		if(null!=this.socket){
			try {
				this.socket.close();
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			this.socket=null;
		}
		e.printStackTrace();
	}
	}

}

通过上面的代码可以看出，每当一个新的客户端请求过来，服务端都需要创建一个新的线程处理新接入的客户端请求，一个线程只能处理一个客户端的请求。在高性能服务器应用领域，往往需要面向成千上万客户端的并发接入，阻塞IO显然无法满足高性能，高并发接入的场景。