[编织消息框架][网络IO模型]BIO

既然跟网络内容有关就不得不学习网络IO模型，时代在进步，技术也在进步，采取使用那种网络IO模型就已经确定应用程序规模

阻塞IO（blocking IO）

在linux中，默认情况下所有的socket都是blocking，一个典型的读操作流程大概是这样：

图1 阻塞IO

大部分的IO接口都是阻塞型的。所谓阻塞型接口是指系统调用（一般是IO接口）不返回调用结果并让当前线程一直阻塞，只有当该系统调用获得结果或者超时出错时才返回。

　　当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据。对于network io来说，很多时候数据在一开始还没有到达（比如，还没有收到一个完整的UDP包），这个时候kernel就要等待足够的数据到来。而在用户进程这边，整个进程会被阻塞。当kernel一直等到数据准备好了，它就会将数据从kernel中拷贝到用户内存，然后kernel返回结果，用户进程才解除block的状态，重新运行起来

所以，blocking IO的特点就是在IO执行的两个阶段（等待数据和拷贝数据两个阶段）都被block了。

　　对于网络编程，在第一阶段系统内核阻塞等侍接收完整数据包，主进程/线程无法执行运算同响应其它请求，非常浪费硬件资源，解决方案是每个socket开个线程/进程独立处理

 public final class ServerBio {
     private static int DEFAULT_PORT = 12345;
     private static ServerSocket server;
     private static AtomicInteger ai = new AtomicInteger();

     public static void main(String[] args) throws Exception {
         try {
             server = new ServerSocket(DEFAULT_PORT);
             System.out.println("服务器已启动，端口号：" + DEFAULT_PORT);
             while (true) {
                 Socket socket = server.accept();
                 ai.incrementAndGet();
                 new Thread(new ServerHandler(socket)).start();
             }
         } finally {
             if (server != null) {
                 System.out.println("服务器已关闭。");
                 server.close();
                 server = null;
             }
         }
     }

     public static class ServerHandler implements Runnable {
     private Socket socket;
     private BufferedReader in = null;
     private PrintWriter out = null;

     public ServerHandler(Socket socket) {
         this.socket = socket;
     }

     @Override
     public void run() {
         try {
         in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
         out = new PrintWriter(socket.getOutputStream(), true);
         String body;
         while (true) {
             if ((body = in.readLine()) == null) {
                 continue;
             }
             System.out.println("服务器收到消息：" + body);
             out.println(ai.get());
         }
         } catch (Exception e) {

         } finally {
             if (in != null) {
                 try {
                     in.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             if (out != null) {
                 out.close();
             }
             if (socket != null) {
                 try {
                     socket.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
     }
 }

 public class ClientBio {
     private static int DEFAULT_SERVER_PORT = 12345;
     private static String DEFAULT_SERVER_IP = "127.0.0.1";
     private static AtomicInteger ai = new AtomicInteger();

     private Socket socket = null;
     private BufferedReader in = null;
     private PrintWriter out = null;

     public static void main(String[] args) throws InterruptedException {
         while (true) {
             send("xxxxxx");
             Thread.sleep(1);
         }
     }

     public static void send(String body) {
         new ClientBio().send(DEFAULT_SERVER_PORT, body);
     }

     public void send(int port, String body) {
         try {
             socket = new Socket(DEFAULT_SERVER_IP, port);
             in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             out = new PrintWriter(socket.getOutputStream(), true);
             out.println(body);
             ai.incrementAndGet();
             System.out.println("客户端 接收：" + in.readLine());
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

BIO有个致命的缺点，由于线程/进程资源是有限的，在测试发现当开了500线程左右每接收/创建一个socket时间变得越来越长，也就是说采用BIO模型的瓶颈在500左右（大众机器）

解决方案也简单：线程是有限的，那么就用池程线来重用线程

ServerBioPool.class 只需要添加ExecutorService pool 替换掉Thread即可

     private static ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*10);
     public static void main(String[] args) throws Exception {
     try {
         server = new ServerSocket(DEFAULT_PORT);
         System.out.println("服务器已启动，端口号：" + DEFAULT_PORT);
         while (true) {
             Socket socket = server.accept();
             ai.incrementAndGet();
             pool.submit(new ServerHandler(socket));
          }
     } finally {
         // 一些必要的清理工作
         if (server != null) {
             System.out.println("服务器已关闭。");
             server.close();
             server = null;
             }
         }
     }

上面应用场景比较有限，如果是长连接不释放socket资源的话，每个socket占用一个thread，用thread pool只能优化thread创建和销毁的频率并不能解决thread不足问题，读者可以试下把线程数改成800再测试。

现实与理想差距还是很大的

我们来论证瓶颈是否出现在线程上，屏蔽掉 ServerBioPool.class ClientBio.class 发送接收处理

    public static void main(String[] args) throws Exception {
        server = new ServerSocket(DEFAULT_PORT);
        System.out.println("服务器已启动，端口号：" + DEFAULT_PORT);
        while (true) {
            Socket socket = server.accept();
            ai.incrementAndGet();
            System.out.println(ai.get());
        }
    }

ClientBio.class

    public void send(int port, String body) {
        try {
            socket = new Socket(DEFAULT_SERVER_IP, port);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

结果打印出的数字能突破成千上万

如果client使用bio是无影响的，因为由始至终只有一个socket

小结:使用BIO模型，性能屏颈受线程/进程数上限影响，client可以使用bio