通信技术整体解决的问题

  • 局域网内通信要求
  • 多系统间的底层消息传递机制
  • 高并发下，大数据量的通信场景需要

I/O 模型

BIO 同步阻塞

同步阻塞IO，服务器实现模式是采用一个连接一个请求，当客户端有连接请求时服务器就需要启动一个线程来处理，当该连接并没有请求要处理时，那么线程就会进行等待，这样就造成了线程的开销

IO模型_服务器

简单来说，就是一旦有一个新的客户端请求连接时，那么服务器就会启动一个线程提供其使用，当该客户端没有任何事要处理时，该线程处于等待状态，这就造成了线程的开销

NIO 同步非阻塞

同步非阻塞通信，即一个线程可以处理多个客户端的请求，客户端的连接都会连接在一个多路复用器上，多路复用器进行轮询查找那个客户端有I/O请求，有就处理

IO模型_客户端_02

简单来说，就是免去了BIO因只要有新的客户端发送I/O请求，服务器就为其开启新的线程的缺点，减少了线程的开销，且线程无需等待

AIO 异步非阻塞

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

各个IO模型的适用场景

  1. BIO 适用于连接数目较少，对服务器要求较高
  2. NIO 适用于连接数目多连接时间短 （聊天服务器）
  3. AIO 适用于连接数目多连接时间长

BIO 深入剖析

基本介绍

同步阻塞，一个连接一个线程，则客户端由连接请求服务器就开启一个线程，当客户端并没有I/O请求要处理时，则线程进行等待

工作机制

代码演示

  • 客户端
public class Client {

    public static void main(String[] args) throws IOException {
        //1. 创建Socket对象请求连接
        // 设置ip地址及端口
        Socket socket = new Socket("127.0.0.1",8888);
        //2. 从socket中获取一个输出流
        OutputStream outputStream = socket.getOutputStream();
        //3. 把字节输出流封装成一个打印流
        PrintStream printStream = new PrintStream(outputStream);
        Scanner scanner = new Scanner(System.in);
        System.out.println("开始。。。");
        while (true) {
            String s = scanner.nextLine();
            printStream.println(s);
            printStream.flush();
        }

    }
}
  • 服务端
public class Server {
    public static void main(String[] args) throws IOException {

        //1. 定义一个ServerSocket对象
        ServerSocket serverSocket = new ServerSocket(8888);
        //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);
        }
    }
}
  • 运行结果

为什么会报错呢？

因为客户端发送一次请求后就终止了，而服务端还在等待客户端的消息，导致连接失败，产生重连

所以我们也许将客户端也进行循环

BIO 模式下一个服务端对应多个客户端

客户端

public class ServerThreadHandler extends Thread{

    private Socket socket;

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

    @Override
    public void run() {
        try {
            InputStream inputStream = socket.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String msg;
            while ((msg= bufferedReader.readLine())!=null){
                System.out.println(Thread.currentThread()+"正在接收消息"+msg);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

public class Server1{
    public static void main(String[] args) throws IOException {
        //1. 定义一个ServerSocket对象
        ServerSocket serverSocket = new ServerSocket(8888);
        //2. 创建Socket请求
        while (true){
            Socket socket = serverSocket.accept();
            new ServerThreadHandler(socket).start();
        }
    }
}

从运行结果中可以看出，当服务端线程并没有接收到请求时，会进行等待

NIO

  • Java NIO（New IO）也有人称之为 java non-blocking IO是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO,传统的IO的read和write只能阻塞执行，线程在读写IO期间不能干其他事情，比如调用socket.read()时，如果服务器一直没有数据传输过来，线程就一直阻塞，而NIO中可以配置socket为非阻塞模式。
  • NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写。
  • NIO 有三大核心部分：Channel( 通道) ，Buffer( 缓冲区), Selector( 选择器)
  • Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。
  • 通俗理解：NIO 是可以做到用一个线程来处理多个操作的。假设有 1000 个请求过来,根据实际情况，可以分配20 或者 80个线程来处理。不像之前的阻塞 IO 那样，非得分配 1000 个。

NIO 与 BIO 的比较

  • BIO 以流的方式处理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多
  • BIO 是阻塞的，NIO 则是非阻塞的
  • BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作，数据总是从通道 读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道

|NIO|BIO| |-|-| |面向缓冲区和通道|面向流| |非阻塞|阻塞| |选择器||

NIO 三大核心原理示意图

NIO 有三大核心部分：Channel( 通道) ，Buffer( 缓冲区), Selector( 选择器)

  • 缓冲区：可以写入数据，也可以从中读取数据的内存
  • Channel：通道，类似于流，既可以向通道中读数据也可以向通道中写数据，但流的读写是单向且堵塞的，通道是双向的且不堵塞，支持异步读写
  • Selector：Selector是 一个Java NIO组件，可以能够检查一个或多个 NIO 通道，并确定哪些通道已经准备好进行读取或写入。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接，提高效率

IO模型_客户端_03

  • 每个 channel 都会对应一个 Buffer
  • 一个线程对应Selector ， 一个Selector对应多个 channel(连接)
  • 程序切换到哪个 channel 是由事件决定的
  • Selector 会根据不同的事件，在各个通道上切换
  • Buffer 就是一个内存块 ， 底层是一个数组
  • 数据的读取写入是通过 Buffer完成的 , BIO 中要么是输入流，或者是输出流, 不能双向，但是 NIO 的 Buffer 是可以读也可以写。
  • Java NIO系统的核心在于：通道(Channel)和缓冲区 (Buffer)。通道表示打开到 IO 设备(例如：文件、 套接字)的连接。若需要使用 NIO 系统，需要获取 用于连接 IO 设备的通道以及用于容纳数据的缓冲 区。然后操作缓冲区，对数据进行处理。简而言之，Channel 负责传输， Buffer 负责存取数据

缓冲区Buffer

主要用于与NIO中的通道进行交互，数据可以从通道读入缓冲区，也可以从缓冲区写入通道

IO模型_非阻塞_04

基本属性

Buffer 中的重要概念：

  • 容量 (capacity) ：作为一个内存块，Buffer具有一定的固定大小，也称为"容量"，缓冲区容量不能为负，并且创建后不能更改。
  • 限制 (limit)：表示缓冲区中可以操作数据的大小（limit 后数据不能进行读写）。缓冲区的限制不能为负，并且不能大于其容量。 写入模式，限制等于buffer的容量。读取模式下，limit等于写入的数据量。
  • 位置 (position)：下一个要读取或写入的数据的索引。缓冲区的位置不能为 负，并且不能大于其限制
  • 标记 (mark)与重置 (reset)：标记是一个索引，通过 Buffer 中的 mark() 方法 指定 Buffer 中一个特定的 position，之后可以通过调用 reset() 方法恢复到这 个 position. 标记、位置、限制、容量遵守以下不变式： 0 <= mark <= position <= limit <= capacity

IO模型_客户端_05

通道(Channel)

通道（Channel）：由 java.nio.channels 包定义 的。Channel 表示 IO 源与目标打开的连接。 Channel 类似于传统的“流”。只不过 Channel 本身不能直接访问数据，Channel 只能与 Buffer 进行交互。

1、 NIO 的通道类似于流，但有些区别如下：

  • 通道可以同时进行读写，而流只能读或者只能写
  • 通道可以实现异步读写数据
  • 通道可以从缓冲读数据，也可以写数据到缓冲:

2、BIO 中的 stream 是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道(Channel) 是双向的，可以读操作，也可以写操作。

3、Channel 在 NIO 中是一个接口

选择器(Selector)

选择器（Selector） 是 SelectableChannle 对象的多路复用器，Selector 可以同时监控多个 SelectableChannel 的 IO 状况，也就是说，利用 Selector可使一个单独的线程管理多个 Channel。Selector 是非阻塞 IO 的核心

  • Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连接，就会使用到 Selector(选择器)
  • Selector 能够检测多个注册的通道上是否有事件发生(注意:多个 Channel 以事件的方式可以注册到同一个 Selector)，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管 理多个通道，也就是管理多个连接和请求。
  • 只有在 连接/通道 真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都 创建一个线程，不用去维护多个线程
  • 避免了多线程之间的上下文切换导致的开销

AIO编程

Java AIO(NIO.2) ： 异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

与NIO不同，当进行读写操作时，只须直接调用API的read或write方法即可, 这两种方法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区,对于写操作而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通知应用程序

即可以理解为，read/write方法都是异步的，

总结

BIO、NIO、AIO：

  • Java BIO ： 同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
  • Java NIO ： 同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
  • Java AIO(NIO.2) ： 异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

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

  • BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。
  • NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持。
  • AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。