Java教程之IO模式精讲，NIO+BIO

2024-07-04 20:32:46

第一章 BIO、NIO、AIO介绍

背景

在java的软件设计开发中，通信架构是不可避免的，我们在进行不同系统或者不同进程之间的数据交互，或者在高并发下的通信场景下都需要用到网络通信相关的技术，对于一些经验丰富的程序员来说，Java早期的网络通信架构存在一些缺陷，其中最令人恼火的是基于性能低下的同步阻塞式的I/O通信（BIO)，随着互联网开发下通信性能的高要求，Java在2002年开始支持了非阴塞式的I/O通信技术（NIO)。大多数读者在学习网络通信相关技术的时候，都只是接触到零碎的通信技术点，没有完整的技术体系架构，以至于对Java的通信场景总是没有清晰的解决方案。本次课程将通过大量清晰直接的案例从最基础的BlO式通信开始介绍到NIO、AIO，读者可以清晰的了解到阻塞、同步、异步的现象、概念和特征以及优缺点。本课程结合了大量的案例让读者可以快速了解每种通信架构的使用。

第二章 Java的I/O演进之路

2.1 I/O模型基本说明

I/O模型：就是用什么样的通道或者说是通信模式和架构进行数据的传输和接收，很大程度上决定了程序通信的性能 , Java共支持3种网络编程的I/O模型：BlO. NIO. AlO实际通信需求下，要根据不同的业务场景和性能需求决定选择不同的I/O模型

2.2 I/O模型

Java BIO

同步并阻塞（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销【简单示意图】

java NIO

Java NIO：同步非阻塞，服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求就进行处理

java AIO

java A!O(NIO.2)：异步异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理，一般适用于连接数较多且连接时间较长的应用

2.3 BIO、NIO、AIO适用场景分析

1、 BIO方式适用于连接数目比小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中， jDK1.4以前的唯一选择，但程序简单易理解。（并发不是特别高的场景）
2、 NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯等。编程比较复杂，jDK1 .4开始支持。
3、 AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

第三章 JAVA BIO深入剖析

3.1 Java BIO基本介绍

Java BlO就是传锤的Java IO编程，其相关的类和接口在Java.io 包中
BIO(blocking I/O)同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善（实现多个客户连接服务器）.

3.2 java BIO工作机制

3.3 传统的BIO编程实例回顾

网络编程的基本模型是Client/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信（绑定IP地址和端口），客户端通过连接操作向服务端监听的端口地址发起连接请求，基于TCP协议下进行三次握手连接，连接成功后，双方通过网络套接字（Socket）进行通信。
传统的同步阻塞模型开发中，服务端ServerSocket负责绑定IP地址，启动监听端口；客户端Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。
基于BIO模式下的通信，客户端-服务端是完全同步，完全藕合的。

客户端案例如下

public class Client {
    public static void main(String[] args) {
        try {
            //1.创建Socket对象请求服务端的连接
            Socket socket = new Socket("127.0.0.1", 9999);
            OutputStream outputStream = socket.getOutputStream();
            PrintStream printStream = new PrintStream(outputStream);
            printStream.println("hello world!服务端，你好");
            printStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务端案例如下

public class Server {
    public static void main(String[] args) {
        try {
            //1.定义一个ServerSocket对象进行服务端的端口注册
            ServerSocket serverSocket = new ServerSocket(9999);
            //2. 监听客户端的Socket连接请求
            Socket socket = serverSocket.accept();
            //3.从socket管道中得到一个字节输入流对象
            InputStream inputStream = socket.getInputStream();
            //4.把字节输入流包装成一个缓存字符输入流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String msg ;
//            while ((msg = bufferedReader.readLine()) != null) {
//                System.out.println("服务端收到消息:" + msg);
//            }
            if ((msg = bufferedReader.readLine()) != null) {
                System.out.println("服务端收到消息:" + msg);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

输出

服务端收到消息:hello world!服务端，你好

小结

在以上通信中，服务端会一直等待客户端的消息，如果客户端没有进行消息的发送，服务端将一直进入阻塞状态
同时服务端是按照行获取消息的，这意味育客户端也必须按照行进行消息的发送，否则服务端将进入等待消息的阻塞状态！

3.4 BIO模式下多发和多收消息

在上面的案例中，只能实现客户端发送消息，服务端接收消息，并不能实现反复的收消息和反复的发消息，我们只需要在客户端案例中，加上反复按照行发送消息的逻辑即可！案例代码如下：

客户端代码如下

public class Client {
    public static void main(String[] args) {
        try {
            //1.创建Socket对象请求服务端的连接
            Socket socket = new Socket("127.0.0.1", 9999);
            OutputStream outputStream = socket.getOutputStream();
            PrintStream printStream = new PrintStream(outputStream);
            Scanner scanner = new Scanner(System.in);
            while (true) {
                System.out.println("你好，请输入");
                String msg = scanner.nextLine();
                printStream.println(msg);
                printStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务端代码如下

public class Server {
    public static void main(String[] args) {
        try {
            //1.定义一个ServerSocket对象进行服务端的端口注册
            ServerSocket serverSocket = new ServerSocket(9999);
            //2. 监听客户端的Socket连接请求
            Socket socket = serverSocket.accept();
            //3.从socket管道中得到一个字节输入流对象
            InputStream inputStream = socket.getInputStream();
            //4.把字节输入流包装成一个缓存字符输入流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String msg ;
            while ((msg = bufferedReader.readLine()) != null) {
                System.out.println("服务端收到消息:" + msg);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

输出

3.5 BIO模式下接收多个客户端

概述
在上述的案例中，一个服务端只能接收一个客户端的通信请求，那么如果服务端需要处理很多个客户端的消息通信请求应该如何处理呢，此时我们就需要在服务端引入线程了，也就是说客户端每发起一个请求，服务端就创建一个新的线程来处理这个客户端的请求，这样就实现了一个客户端一个线程的模型，
图解模式如下

服务端案例代码

public class Server {
    public static void main(String[] args) {
        try {
            //1.注册端口
            ServerSocket serverSocket = new ServerSocket(9999);
            //2.定义一个死循环，负责不断的接收客户端的Socket的连接请求
            while (true) {
                Socket socket = serverSocket.accept();
                //3.创建一个独立的线程来处理与这个客户端的socket通信需求
                new ServerThreadReader(socket).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

线程类

public class ServerThreadReader extends Thread{
    private Socket socket;

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

    @Override
    public void run() {
        try {
            //从socket对象中得到一个字节输入流
            InputStream inputStream = socket.getInputStream();
            //使用缓存字符输入流包装字节输入流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String msg ;
            while ((msg = bufferedReader.readLine()) != null) {
                System.out.println("服务端收到消息:" + msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端案例代码

public class Client {
    public static void main(String[] args) {
        try {
            //1.创建Socket对象请求服务端的连接
            Socket socket = new Socket("127.0.0.1", 9999);
            OutputStream outputStream = socket.getOutputStream();
            //2. 得到一个打印流
            PrintStream printStream = new PrintStream(outputStream);
            //3. 使用循环不断的发送消息给服务端接收
            Scanner scanner = new Scanner(System.in);
            while (true) {
                System.out.println("你好，请输入");
                String msg = scanner.nextLine();
                printStream.println(msg);
                printStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

小结

每个Socket接收到，都会创建一个线程，线程的竞争、切换上下文影响性能；・
每个线程都会占用栈空间和CPU资源；
并不是每个socket都进行lO操作，无意义的线程处理；
客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。

3.6 伪异步I/O编程

概述
在上述案例中：客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。
接下来我们采用一个伪异步I/O的通信框架，采用线程池和任务队列实现，当客户端接入时，将客户端的Socket封装成一个Task(该任务实现Java. lang. Runnable(线程任务接口）交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程，对消息队列中Socket任务进行处理，由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机

如下图所示：

客户端源码分析

public class Client {
    public static void main(String[] args) {
        try {
            //1.创建Socket对象请求服务端的连接
            Socket socket = new Socket("127.0.0.1", 9999);
            OutputStream outputStream = socket.getOutputStream();
            //2. 得到一个打印流
            PrintStream printStream = new PrintStream(outputStream);
            //3. 使用循环不断的发送消息给服务端接收
            Scanner scanner = new Scanner(System.in);
            while (true) {
                System.out.println("你好，请输入");
                String msg = scanner.nextLine();
                printStream.println(msg);
                printStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

线程池处理类

public class HandlerSocketServerPool {
    //1. 创建一个线程池的成员变量用于存储一个线程池对象
    private ExecutorService executorService;

    /**
     * 2.创建这个类的的对象的时候就需要初始化线程池对象
     * @param maxThreadNum
     * @param queueSize
     */
    public HandlerSocketServerPool(int maxThreadNum, int queueSize){
        executorService = new ThreadPoolExecutor(3,maxThreadNum,120,
                TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
    }

    /**
     * 3.提供一个方法来提交任务给线程池的任务队列来暂存，等待线程池来处理
     * @param target
     */
    public void execute(Runnable target){
        executorService.execute(target);
    }
}

Socket任务类

public class ServerRunnableTarget implements Runnable{
    private Socket socket;

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

    @Override
    public void run() {
        try {
            //从socket对象中得到一个字节输入流
            InputStream inputStream = socket.getInputStream();
            //使用缓存字符输入流包装字节输入流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String msg ;
            while ((msg = bufferedReader.readLine()) != null) {
                System.out.println("服务端收到消息:" + msg);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

服务端源码分析

public class Server {
    public static void main(String[] args) {
        try {
            //1.注册端口
            ServerSocket serverSocket = new ServerSocket(9999);
            //2.定义一个死循环，负责不断的接收客户端的Socket的连接请求
            //初始化一个线程池对象
            HandlerSocketServerPool pool = new HandlerSocketServerPool(3,10);
            while (true) {
                Socket socket = serverSocket.accept();
                //3.把socket对象交给一个线程池进行处理
                //把socket封装成一个任务对象交给线程池处理
                Runnable target = new ServerThreadReader(socket);
                pool.execute(target);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出

小结

伪异步旧采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题，但由于底层依然是采用的同步阻塞模型，因此无法从根采上解决问题。
如果单个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那么后续socket的I/O消息都将在队列中排队。新的Socket请求将被拒绝，客户端会发生大量连接超

3.7 基于BIO形式下的文件上传

目标
支持任意类型文件形式的上传

客户端开发

public class Client {
    public static void main(String[] args) {
        try {
            //1.请求与服务端的Socket连接
            Socket socket = new Socket("127.0.0.1", 8888);
            //2.把字节输出流包装成一个数据输出流(DataOutputStream可以做分段数据发送)
            DataOutputStream dataOutputStream = new DataOutputStream(socket.getOutputStream());
            //3.先发送上传文件的后缀给服务器
            dataOutputStream.writeUTF(".jpg");
            //4.把文件数据发送给服务端进行接收
            InputStream is = new FileInputStream("C:\\Users\\dell\\Desktop\\西湖\\31d4cb205e149f28ef649b9a7603b5de_small122004MXRWF1694665204.jpg");
            byte[] buffer = new byte[1024];
            int len;
            while((len=is.read(buffer))>0){
                dataOutputStream.write(buffer,0,len);
            }
            dataOutputStream.flush();
            socket.shutdownOutput();//通知服务端，我客户端这边的数据已经发送完毕了
        }catch (Exception e){
			e.printStackTrace();
        }
    }
}

服务端开发

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8888);
            while (true) {
                Socket socket = serverSocket.accept();
                new ServerThreadReader(socket).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

服务端线程处理类

public class ServerThreadReader extends Thread{
    private Socket socket;

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

    @Override
    public void run() {
        try {
            //1.得到一个数据输入流来读取客户端发送过来的数据
            DataInputStream dis = new DataInputStream(socket.getInputStream(

上一篇：基于线调频小波变换的非平稳信号分析方法（MATLAB）
下一篇：大数据------JavaWeb------Maven（完整知识点汇总）

码农公寓