Java之BIO网络编程

Posted 2022-12-14 敲代码的小小酥

常用套路

在网络编程中，提供服务的叫服务端，连接服务的叫客户端。在开发过程中，带有Server或者ServerSocket字样的类，是给服务端使用的，如果只有Socket字样的类，就是负责具体网络读写的。

对于服务端而言，ServerSocket只是个场所，不负责具体读写操作，只负责连接客户端之后新建一个socket和客户端进行沟通。具体和客户端沟通的还是一个一个Socket类。这一点对所有模式的网络编程都是通用的。

在网络编程里，我们只需要关注三个事情即可:连接(客户端连接服务器，服务器等待和接收连接)、读网络数据、写网络数据。服务端提供 IP 和监听端口，客户端通过连接操作想服务端监听的地址发起连接请求，连接成功建立，双方就可以通过套接字进行通信。

BIO

采用 BIO 通信模型的服务端，通常由一个独立的 Acceptor 线程负责监听客户端的连接，它接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理，处理完成后，通过输出流返回应答给客户端，线程销毁。即典型的一请求一应答模型，同时数据的读取写入也必须阻塞在一个线程内等待其完成。

该模型最大的问题就是缺乏弹性伸缩能力，当客户端并发访问量增加后，服务端的线程个数和客户端并发访问数呈 1:1 的正比关系，Java 中的线程也是比较宝贵的系统资源，线程数量快速膨胀后，系统的性能将急剧下降，随着访问量的继续增大，系统最终就死-掉-了。

为了改进这种一连接一线程的模型，我们可以使用线程池来管理这些线程，实现 1 个或多个线程处理 N 个客户端的模型（但是底层还是使用的同步阻塞 I/O），通常被称为“伪异步 I/O 模型“。

代码实现

客户端:

public class Client 

    public static void main(String[] args) throws IOException 
        //客户端启动必备
        Socket socket = null;
        //实例化与服务端通信的输入输出流
        ObjectOutputStream output = null;
        ObjectInputStream input = null;
        //服务器的通信地址
        InetSocketAddress addr
                = new InetSocketAddress("127.0.0.1",10001);

        try
            socket = new Socket();
            socket.connect(addr);//连接服务器

            output = new ObjectOutputStream(socket.getOutputStream());
            input = new ObjectInputStream(socket.getInputStream());

            /*向服务器输出请求*/
            output.writeUTF("ceshi");
            output.flush();

            //接收服务器的输出
            System.out.println(input.readUTF());
        finally
            if (socket!=null) socket.close();
            if (output!=null) output.close();
            if (input!=null) input.close();

        
    

服务端:

public class Server 

    public static void main(String[] args) throws IOException 
        //服务端启动必备
        ServerSocket serverSocket = new ServerSocket();
        //表示服务端在哪个端口上监听
        serverSocket.bind(new InetSocketAddress(10001));
        System.out.println("Start Server ....");
        try
            while(true)
            //当有客户端连接时，会执行完一次循环，到下一次循环时，如果没有客户端连接，则一直阻塞在serverSocket.accept()方法那里，不往下执行，直到下一个客户端连接过来
                new Thread(new ServerTask(serverSocket.accept())).start();
            
        finally 
            serverSocket.close();
        
    

    //每个和客户端的通信都会打包成一个任务，交个一个线程来执行
    private static class ServerTask implements Runnable

        private Socket socket = null;
        public ServerTask(Socket socket)
            this.socket = socket;
        

        @Override
        public void run() 
            //实例化与客户端通信的输入输出流
            try(ObjectInputStream inputStream =
                    new ObjectInputStream(socket.getInputStream());
                ObjectOutputStream outputStream =
                    new ObjectOutputStream(socket.getOutputStream()))

                //接收客户端的输出，也就是服务器的输入
                String userName = inputStream.readUTF();
                System.out.println(Thread.currentThread().getName()+"Accept client message:"+userName);

                //服务器的输出，也就是客户端的输入
                outputStream.writeUTF(Thread.currentThread().getName()+"Hello,"+userName);
                outputStream.flush();
            catch(Exception e)
                e.printStackTrace();
            finally 
                try 
                    socket.close();
                 catch (IOException e) 
                    e.printStackTrace();
                
            
        
    

线程池实现服务端:

public class ServerPool 

    private static ExecutorService executorService
            = Executors.newFixedThreadPool(
                    Runtime.getRuntime().availableProcessors());

    public static void main(String[] args) throws IOException 
        //服务端启动必备
        ServerSocket serverSocket = new ServerSocket();
        //表示服务端在哪个端口上监听
        serverSocket.bind(new InetSocketAddress(10001));
        System.out.println("Start Server ....");
        try
            while(true)
                executorService.execute(new ServerTask(serverSocket.accept()));
            
        finally 
            serverSocket.close();
        
    

    //每个和客户端的通信都会打包成一个任务，交个一个线程来执行
    private static class ServerTask implements Runnable

        private Socket socket = null;
        public ServerTask(Socket socket)
            this.socket = socket;
        

        @Override
        public void run() 
            //实例化与客户端通信的输入输出流
            try(ObjectInputStream inputStream =
                    new ObjectInputStream(socket.getInputStream());
                ObjectOutputStream outputStream =
                    new ObjectOutputStream(socket.getOutputStream()))

                //接收客户端的输出，也就是服务器的输入
                String userName = inputStream.readUTF();
                System.out.println("Accept client message:"+userName);

                //服务器的输出，也就是客户端的输入
                outputStream.writeUTF("Hello,"+userName);
                outputStream.flush();
            catch(Exception e)
                e.printStackTrace();
            finally 
                try 
                    socket.close();
                 catch (IOException e) 
                    e.printStackTrace();
                
            
        
    

对阻塞的理解

bio的阻塞，主要体现在两个地方：
①若一个服务器启动就绪，那么主线程就一直在等待着客户端的连接，这个等待过程中主线程就一直在阻塞。即socketServer.accept()方法，当有客户端连接时，才会往下执行代码。否则会一直阻塞在这里。

②在连接建立之后，一个子线程服务于这个连接，那么这个子线程提供的服务无非就是socket通信，在读取到socket信息之前，这个子线程也是一直在等待，一直处于阻塞的状态下的。

线程池实现的伪异步IO只是减少了客户端连接服务端时新线程创建的数量，对阻塞没有任何帮助。