[编织消息框架][网络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