【NIO引入】传统的IO模型

传统的BIO模型

服务端代码：

public class Server1 {

    public static void main(String[] args) {
        System.out.println("服务器启动...");
        Socket client = null;
        BufferedReader in = null;
        PrintWriter pw = null;
        BufferedReader br = null;
        try {
            ServerSocket server = new ServerSocket(8080);
            while (true) {
                //阻塞等待
                client = server.accept();
                in = new BufferedReader(new InputStreamReader(client.getInputStream()));
                pw = new PrintWriter(client.getOutputStream());
                br = new BufferedReader(new InputStreamReader(System.in));

                String s = in.readLine();
                System.out.println("客户端： " +s);
                pw.println(br.readLine());
                pw.flush();
                if("end".equals(s)){
                    System.out.println("服务器将关闭连接");
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                br.close();
                pw.close();
                in.close();
                client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

客户端代码：

public class Client1 {


    public static void main(String[] args) {
        System.out.println("客户端1启动...");
        System.out.println("当输入 \" end \" 时, 客户端将终止\n");
        Socket server = null;
        Socket client = null;
        BufferedReader in = null;
        PrintWriter pw = null;
        BufferedReader br = null;
        try {
            while (true) {
                server = new Socket(InetAddress.getLocalHost(), 8080);
                br = new BufferedReader(new InputStreamReader(System.in));
                pw = new PrintWriter(server.getOutputStream());
                in = new BufferedReader(new InputStreamReader(server.getInputStream()));

                String str = br.readLine();

                pw.println(str);
                pw.flush();

                if("end".equals(str)){
                    System.out.println("客户端将关闭连接");
                    break;
                }
                System.out.println("服务器： "+in.readLine());
            }

        }catch (IOException e) {
                e.printStackTrace();
            }finally {
            try {
                in.close();
                pw.close();
                br.close();
                server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}

分析：采用BIO通信模型的服务端。通常由一个独立的Acceptor线程负责监听客户端的连接，它接收到客户端的连接请求后为每一个客户端创建一个新的线程，处理完成后销毁线程，这是典型的一对一模型。

缺点：当客户端并发访问量增加后，服务端不得不创建多个线程，但线程是Java虚拟机非常宝贵的资源，系统会发生堆栈溢出、创建新线程失败等问题。

解决方法：创建一个线程池来存放新建的客户端连接（即伪异步模型）。

伪异步IO模型

服务端代码：

public class Server2 {

    public static void main(String[] args) throws IOException {
        ServerSocket server = null;
        try {
            server = new ServerSocket(8080);
            System.out.println("服务端启动...... ");
            Socket socket = null;
            TimeServerHandlerExecutePool singleExecutor = new TimeServerHandlerExecutePool(
                    50, 10000);// 创建IO任务线程池
            while (true) {
                socket = server.accept();
                singleExecutor.execute(new TimeServerHandler(socket));
            }
        } finally {
            if (server != null) {
                server.close();
                server = null;
            }
        }
    }
}

class TimeServerHandlerExecutePool {

    private ExecutorService executor;

    public TimeServerHandlerExecutePool(int maxPoolSize, int queueSize) {
        executor = new ThreadPoolExecutor(Runtime.getRuntime()
                .availableProcessors(), maxPoolSize, 120L, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(queueSize));
    }

    public void execute(java.lang.Runnable task) {
        executor.execute(task);
    }
}

class TimeServerHandler implements Runnable {

    private Socket socket;

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

    @Override
    public void run() {
        BufferedReader br = null;
        PrintWriter pw = null;
        try {
            br = new BufferedReader(new InputStreamReader(
                    this.socket.getInputStream()));
            pw = new PrintWriter(socket.getOutputStream());
            br = new BufferedReader(new InputStreamReader(System.in));

            String s = br.readLine();
            System.out.println("客户端： " +s);
            pw.println(br.readLine());
            pw.flush();
        } catch (Exception e) {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            if (pw != null) {
                pw.close();
                pw = null;
            }
            if (this.socket != null) {
                try {
                    this.socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
                this.socket = null;
            }
        }
    }
}

客户端代码不变（同BIO）

分析：伪异步IO虽然采用了线程池，避免了一请求一连接的问题，但它的底层还是采用同步阻塞模型，其最本质的问题在于，严重依赖于线程。但线程是很”贵”的资源
，因为线程的创建和销毁成本很高。

缺点：

• 由于线程池采用阻塞队列实现。当队列积满后，后续队列的操作将被阻塞。

• 线程的切换成本高的。

总结：

当面对十万甚至百万级连接的时候，传统的BIO模型是无能为力的。这就需要一种更高效的I/O处理模型。

本人才疏学浅，若有错误，请指出
谢谢！