Java BIO 模型示例

SocketBIO.java

package org.io.bio;

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

/**
 * BIO（阻塞IO） 典型的网络编程模型
 *
 * jdk 1.4 演示
 * 示例：服务器启动后，等待客户端连接，在客户端连接服务器后，服务器就阻塞读写数据流。
 *      服务线程（主线程）阻塞于 accept 等待客户端连接
 *      连接后，服务线程阻塞于 Socket 读写数据流程，等待客户段向 Socket 输入数据
 *
 * Linux 系统调用跟踪：strace -ff -o out /opt/java/j2sdk1.4.2_19/bin/java -classpath ./target SocketBIO
 *      与客户端建立链接：系统调用 accept(3,  ..... 阻塞，等带客户端链接
 *      接受客户端消息：系统调用 recv(5,  ......... 阻塞，等待链接的客户端输入
 *
 * 单线程（所有连接都使用主线程）: recv 阻塞会导致其他链接全部阻塞，无法链接服务。
 *
 * 弊端：IO请求阻塞、一次只能处理一个客户端连接。
 * 优化：【BIO + 多线程】为每个连接创建一个线程。见 SocketBIOMultiThread 示例
 *
 */
public class SocketBIO {
    public static void main(String[] args) throws IOException {
        try {
            ServerSocket serverSocket = new ServerSocket(9000,20);
            System.out.println("step1: new ServerSocket, port:9000");
            Socket clientSocket = serverSocket.accept();    // 阻塞1：等待链接

            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),true);
            BufferedReader in =  new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

            String inputLine ;
            // 阻塞2：等待输入 （如果连接的客户端关闭，这里就推出循环了 ——> 主线程将结束）
            while ((inputLine = in.readLine()) != null){
                System.out.println(clientSocket.getInetAddress() + ":"
                        + clientSocket.getPort()
                        + "client send message:" + inputLine);
                out.println("Server Socket get!");
            }

        }catch (IOException ioException){
            System.out.println("");
            ioException.printStackTrace();
        }
    }
}

SocketBIOMultiThread

package org.io.bio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * BIO（阻塞IO） + 多线程
 *
 * 示例：每个链接占用一个线程
 *      主线程 accept 连接请求阻塞
 *          客户端连接请求到达，创建新的线程来处理这个套接字，完成对客户端的响应（该线程阻塞，等待内核的 IO 操作返回）。
 *          这样主线程就可以继续等待下一个客户端连接 ————> 线程 IO 阻塞不会导致到其他客户端连接阻塞。
 *
 * jdk 1.4 演示
 * 与客户段简历链接：系统调用 accept(3,  ..... 阻塞，等带客户端链接
 * 新建线程：系统调用 clone
 * 接受客户端消息：系统调用 recv(5,  ......... 阻塞，等待链接的客户端输入
 *
 * 如果使用单线程（所有连接都使用主线程）: recv 阻塞会导致其他链接全部阻塞，无法链接。
 * 如果使用多线程（为每个连接创建单独的线程，如本例）: recv 阻塞不影响其他客户端连接，系统调用多，开销大。
 *
 * 弊端：每次收到新的连接都要新建一个线程，处理完后销毁线程，代价大。当有大量的短连接出现时，服务端创建的线程也会暴涨，系统性能会急剧下降。
 * 优化：在此模型的基础上，类似于 tomcat的 bio connector，
 *      采用【BIO + 线程池】来避免对于每一个客户端都创建一个线程（减少线程创建的系统调用），控制线程数量保证系统性能。
 *      见示例：SocketBIOMultiThreadPool
 *
 */
public class SocketBIOMultiThread {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9000,20);
        System.out.println("step1: new ServerSocket, port:9000");

        while (true){
            final Socket client = serverSocket.accept();          // 阻塞1：等待链接
            System.out.println("step2: accept() client: pore \t" + client.getPort());

            //每个连接创建一个线程
            Thread thread = new Thread(new Runnable() {

                public void run() {
                    InputStream in = null;
                    try {
                        in = client.getInputStream();
                        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                        while (true) {
                            String line = reader.readLine();    // 阻塞2：等待输入
                            if (line != null) {
                                System.out.println(line);
                            } else {
                                client.close();
                                break;
                            }
                        }
                        System.out.println( client.getInetAddress() + ":" + client.getPort() + " closed!");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
            thread.start();
        }
    }
}

SocketBIOMultiThreadPool

package org.io.bio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * BIO（阻塞IO） + 线程池
 * <p>
 * 与客户段简历链接：系统调用 accept(3,  ..... 阻塞，等带客户端链接
 * 从线程池中获取线程：线程复用
 * 接受客户端消息：系统调用 recv(5,  ......... 阻塞，等待链接的客户端输入
 * <p>
 * 如果使用单线程（所有连接都使用主线程）: recv 阻塞会导致其他链接全部阻塞，无法链接。
 * 如果使用多线程（为每个连接创建单独的线程）: recv 阻塞不影响其他客户端连接，系统调用多，开销大，
 * 如果使用线程池（每个连接一个线程，从线程池中获取空闲线程，免了频繁地创建和销毁线程带来的开销）：
 * 适用于短链接，长连接一直占用线程，会影响到其他客户端连接
 * <p>
 * 总结：三种 BIO 方案，都避免不了 BIO 模型的本质缺陷：阻塞，即：用户线程需要等待系统调用的完成。
 */
public class SocketBIOMultiThreadPool {
    public static void main(String[] args) throws IOException {

        // 创建一个初始 5 个线程的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(5);

        ServerSocket serverSocket = new ServerSocket(9000, 20);
        System.out.println("step1: new ServerSocket, port:9000");

        while (true) {
            final Socket client = serverSocket.accept();          // 阻塞1：等待链接
            System.out.println("step2: accept() client: pore \t" + client.getPort());

            // 从线程池中获取空闲线程
            threadPool.submit(new Thread(new Runnable() {

                public void run() {
                    InputStream in = null;
                    try {
                        in = client.getInputStream();
                        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                        while (true) {
                            String line = reader.readLine();    // 阻塞2：等待输入
                            if (line != null) {
                                System.out.println(line);
                            } else {
                                client.close();
                                break;
                            }
                        }
                        System.out.println(client.getInetAddress() + ":" + client.getPort() + " closed!");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }));
        }
    }
}