JAVA网络编程（一）：阻塞IO实现

最近想彻底弄明白Java网络编程，就结合一些资料自己捣鼓了下。

先从BIO说起吧。

BIO就是Blocking IO，通过acceptor监听客户端的连接，来一个客户端就新建一个线程处理，完成处理之后通过输出流应答客户端，最后销毁线程。多说无益，上图（太cho）丑，凑合看）

服务端类：

public class BlockTimeServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(8080);
            Socket socket = null;
            while (true) {
                System.out.println("等待连接");
                socket = serverSocket.accept();//这个方法会一直阻塞至有客户端连接
                new Thread(new BlockTimeServerHandler(socket)).start();//启动线程处理，主线程会继续阻塞等待下一个客户端连接
                System.out.println("已连接");
            }

        } catch (IOException e1) {
            e1.printStackTrace();
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                    serverSocket = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } finally {

        }

    }
}

服务端处理的句柄：

public class BlockTimeServerHandler implements Runnable {
    private Socket socket;
    public BlockTimeServerHandler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        System.out.println("启动线程");
        BufferedReader reader = null;
        PrintWriter writer = null;
        try {
            reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            writer = new PrintWriter(socket.getOutputStream(), true);
            while (true) {
                String request = reader.readLine();//之前一直阻塞，矮凳子绊倒人，忘了行要结尾
                if (request == null) {
                    break;
                }
                System.out.println("get order:" + request);//接收端用到的是readLine方法，这里必须是println，否则会一直阻塞
                String response = "getTime".equals(request) ? new Date().toString() : "bad order";
                System.out.println("response time :"+response);
                writer.println(response);
            }

        } catch (IOException e1) {
            e1.printStackTrace();
            if (reader != null) {
                try {
                    reader.close();
                    reader = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (writer != null) {
                writer.close();
                writer = null;
            }
            if (socket != null) {
                try {
                    socket.close();
                    socket = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端代码：

public class BlockTimeClient {
    public static void main(String[] args) {
        Socket socket = null;
        BufferedReader reader = null;
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            socket = new Socket("localhost", 8080);
            System.out.println("请输入指令");
            reader = new BufferedReader(new InputStreamReader(System.in));
            String order = reader.readLine();
            System.out.println("发送指令："+order);
            out = new PrintWriter(socket.getOutputStream(),true);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out.println(order);
            System.out.println("发送成功");

            String resp = in.readLine();
            System.out.print("收到返回：");
            System.out.println(resp);
            socket.close();
        } catch (IOException e1) {
            e1.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                    socket = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (reader != null) {
                try {
                    reader.close();
                    reader = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (in != null) {
                try {
                    in.close();
                    in = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null) {
                out.close();
                out = null;
            }
        }
    }
}

这种方法中，每个连接过来服务端都会创建一个线程处理，而线程是系统的稀缺资源，如果每个请求都要新建线程，将可能导致服务器资源耗尽，因此明显这种实现方式是不能处理海量请求的，有一个解决方案是使用线程池。线程池是启动前已经初始化好的，不论后来的请求怎么增加，线程数始终都在线程池的最大数量之中，因此不会出现服务器资源耗尽的情况，这种方式被称为伪异步方式。上代码（只需要改动acceptor就可以）：

public class BlockTimeWithPoolServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        try {
            serverSocket = new ServerSocket(8080);
            Executor executor = Executors.newFixedThreadPool(100);
            while (true) {
                socket = serverSocket.accept();
                executor.execute(new BlockTimeServerHandler(socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件参考：《netty权威指南》