java高并发实战（八）——BIO、NIO和AIO

Dear 丶 2022-05-21 04:22 139阅读 0赞

由于之前看的容易忘记，因此特记录下来，以便学习总结与更好理解，该系列博文也是第一次记录，所有有好多不完善之处请见谅与留言指出，如果有幸大家看到该博文，希望报以参考目的看浏览，如有错误之处，谢谢大家指出与留言。

**一、什么是NIO？**

NIO是New I/O的简称，与旧式的基于流的I/O方法相对，从名字看，它表示新的一套Java I/O标准。是一种多路复用；它是在Java 1.4中被纳入到JDK中的，并具有以下特性：

– NIO是**基于块（Block）**的，它以块为基本单位处理数据而传统IO是以字节流的形式，因此NIO性能好一些。

– 为所有的原始类型提供**（Buffer）缓存**支持– 增加**通道（Channel）对象**（作为新的原始 I/O 抽象）

– **支持锁**（文件锁：有些程序运行时产生.log文件，他就是文件锁，表示当前线程在占用文件锁，其他线程要使用该锁时，需要等待阻塞，当使用完锁时后会删除该文件，也就是拿文件系统来实现锁）和**内存映射文件的文件访问接口**（一个文件在硬盘磁盘中的，把文件映射到内存，把文件读到内存中，比传统把文件中数据一个个读进去快的多）

– 提供了基于Selector的**异步网络I/O**

详细请看[https://blog.csdn.net/gududedabai/article/details/80783994][https_blog.csdn.net_gududedabai_article_details_80783994]

**二、Buffer&Channel**

![70][]

所有的IO/NIO操作（读写）都要经过Buffer,他是NIO核心部分。通道就是一个抽象，他的一端可能是一个文件或socket等，往里写数据。也就是说通过对buffer读写来对实际的NIO目标来读取实现等。

缓冲区(Buffer)就是在内存中预留指定大小的存储空间用来对输入/输出(I/O)的数据作临时存储，这部分预留的内存空间就叫做缓冲区：

使用缓冲区有这么两个好处：

1、减少实际的物理读写次数

2、缓冲区在创建时就被分配内存，这块内存区域一直被重用，可以减少动态分配和回收内存的次数

举个简单的例子，比如A地有1w块砖要搬到B地

由于没有工具（缓冲区），我们一次只能搬一本，那么就要搬1w次（实际读写次数）

如果A，B两地距离很远的话（IO性能消耗），那么性能消耗将会很大

但是要是此时我们有辆大卡车（缓冲区），一次可运5000本，那么2次就够了

相比之前，性能肯定是大大提高了。

Buffer类详细用法：[https://www.cnblogs.com/jiduoduo/p/6397454.html][https_www.cnblogs.com_jiduoduo_p_6397454.html]

下面是buffer的实现：

**1、buffer**

![70 1][]

buffer简单的使用：

FileInputStream fin = new FileInputStream(new File("d:\\temp_buffer.tmp"));
    FileChannel fc=fin.getChannel();
    ByteBuffer byteBuffer=ByteBuffer.allocate(1024);//ByteBuffer.allocate()方法分配了一段内存空间，作为缓存
    fc.read(byteBuffer);
    fc.close();
    byteBuffer.flip();//读写转换

**（1）通过NIO复制文件**

public static void nioCopyFile(String resource, String destination)
    throws IOException {
    FileInputStream fis = new FileInputStream(resource);
    FileOutputStream fos = new FileOutputStream(destination);
    FileChannel readChannel = fis.getChannel(); //读文件通道
    FileChannel writeChannel = fos.getChannel(); //写文件通道
    ByteBuffer buffer = ByteBuffer.allocate(1024); //读入数据缓存
    while (true) {
    buffer.clear();
    int len = readChannel.read(buffer); //读入数据
    if (len == -1) {
    break;
    //读取完毕
    }
    buffer.flip();
    writeChannel.write(buffer);
    //写入文件
    }
    readChannel.close();
    writeChannel.close();
    }

**（2）Buffer中有3个重要的参数：位置（position）、容量（capactiy）和上限（limit）**

![70 2][]

通过案例了解三个参数的意义：

ByteBuffer b=ByteBuffer.allocate(15); //15个字节大小的缓冲区
    System.out.println("limit="+b.limit()+" capacity="+b.capacity()+" position="+b.position());
    for(int i=0;i<10;i++){ //存入10个字节数据
    b.put((byte)i);
    }
    System.out.println("limit="+b.limit()+" capacity="+b.capacity()+" position="+b.position());
    b.flip(); //重置position
    System.out.println("limit="+b.limit()+" capacity="+b.capacity()+" position="+b.position());
    for(int i=0;i<5;i++){
    System.out.print(b.get());
    }
    System.out.println();
    System.out.println("limit="+b.limit()+" capacity="+b.capacity()+" position="+b.position());
    b.flip();
    System.out.println("limit="+b.limit()+" capacity="+b.capacity()+" position="+b.position());

![70 3][]

![70 4][]

flip转换主要两步操作:把postition置零；把limit前移到10，就是迁移到刚才postition的位置（好处是，下一次操作自然是从postiton的0开始，操作到那一步是有意义的呢，就是limit的位置，换句话说，从postition到limit之间数据是我上一次写入的的数据而且是有意义的数据，从limit到capacity并不是我上次写入的数据，可能是没有意义的数据，因此在此时读缓冲区，就可以读postition到limit之间的数据就可以了，因此flip通常用于读写转换，在filp之前用于写，在filp之后通常用于读，读使因为位置已经置零了，而且此时数据到limit是有意义的数据。）。

该操作会重置position，通常，将buffer从写模式转换为读模式时需要执行此方法flip()操作不仅重置了当前的position为0，还将limit设置到当前position的位置。

![70 5][]

 public final Buffer rewind()

– 将position置零，并清除标志位（mark）就是把之前读的数据在扫一遍，limit位置是不变的，因此数据是基本一样的

 public final Buffer clear()

– 将position置零，同时将limit设置为capacity的大小，并清除了标志mark

 public final Buffer flip()

– 先将limit设置到position所在位置，然后将position置零，并清除标志位mark– 通常在读写转换时使用

**（3）文件映射到内存**

RandomAccessFile raf = new RandomAccessFile("C:\\mapfile.txt", "rw");
    FileChannel fc = raf.getChannel();
    //将文件映射到内存中
    MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, raf.length());
    while(mbb.hasRemaining()){
    System.out.print((char)mbb.get());
    }
    mbb.put(0,(byte)98); //修改文件
    raf.close();

**三、网络编程**

**多线程网络服务器的一般结构**

**![70 6][]**

**下面实现上面简单案例：**

**1.简单案例 EchoServer**

ServerSocket echoServer = null;
     Socket clientSocket = null;
     try {
     echoServer = new ServerSocket(8000);
     } catch (IOException e) {
     System.out.println(e);
     }
     while (true) {
     try {
     clientSocket = echoServer.accept();
     System.out.println(clientSocket.getRemoteSocketAddress() + " connect!");
     tp.execute(new HandleMsg(clientSocket));
     } catch (IOException e) {
     System.out.println(e);
     }
     }
     }

static class HandleMsg implements Runnable{
    省略部分信息
     public void run(){
     try {
     is = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
     os = new PrintWriter(clientSocket.getOutputStream(), true);
     // 从InputStream当中读取客户端所发送的数据
     String inputLine = null;
     long b=System.currentTimeMillis();//统计时间戳
     while ((inputLine = is.readLine()) != null) {
     os.println(inputLine);
     }
     long e=System.currentTimeMillis();
     System.out.println("spend:"+(e-b)+"ms");
     } catch (IOException e) {
     e.printStackTrace();
     }finally{
    关闭资源
    }
     }

**2.EchoServer的客户端**

public static void main(String[] args) throws IOException {
     Socket client = null;
     PrintWriter writer = null;
     BufferedReader reader = null;
     try {
     client = new Socket();//创建socket
     client.connect(new InetSocketAddress("localhost", 8000));
     writer = new PrintWriter(client.getOutputStream(), true);
     writer.println("Hello!");
     writer.flush();
     reader = new BufferedReader(new InputStreamReader(client.getInputStream()));//读数据，服务器返回的数据从socket中
     System.out.println("from server: " + reader.readLine());
     } catch
     } finally {
     //省略资源关闭
     }
    }

 问题：

– 为每一个客户端使用一个线程，如果客户端出现延时等异常，线程可能会被占用很长时间。因为数据的准备和读取都在这个线程中。

– 此时，如果客户端数量众多，可能会消耗大量的系统资源

 解决

– 非阻塞的NIO

– 数据准备好了在工作

**3.网络编程-模拟低效的客户端**

private static ExecutorService tp=Executors.newCachedThreadPool();
    private static final int sleep_time=1000*1000*1000;
    public static class EchoClient implements Runnable{
    public void run(){
     try {
     client = new Socket();
     client.connect(new InetSocketAddress("localhost", 8000));//开辟若干个线程
     writer = new PrintWriter(client.getOutputStream(), true);
     writer.print("H");
     LockSupport.parkNanos(sleep_time);
     writer.print("e");
     LockSupport.parkNanos(sleep_time);
     writer.print("l");
     LockSupport.parkNanos(sleep_time);
     writer.print("l");
     LockSupport.parkNanos(sleep_time);
     writer.print("o");
     LockSupport.parkNanos(sleep_time);
     writer.print("!");
     LockSupport.parkNanos(sleep_time);
     writer.println();
     writer.flush();

服务器输出如下：

spend:6000ms
    spend:6000ms
    spend:6000ms
    spend:6001ms
    spend:6002ms
    spend:6002ms
    spend:6002ms
    spend:6002ms
    spend:6003ms
    spend:6003ms

**4.网络编程-NIO**

** 把数据准备好了再通知我**

**    Channel有点类似于流，一个Channel可以和文件或者网络Socket对应**

**![70 7][]**

**一个线程（也就是selector）可以轮询多个channel，每一个channl下面对应一个socket。**

**select()与****selectNow()用来看那个channel(客户顿)准备好数据，selector用select（）当数据没有转备好他会被阻塞.**

**selectNow()与select()一样，但区别是他是无阻赛的，没有转备好则返回0；**

 总结：

– NIO会将数据准备好后，再交由应用进行处理（因此数据没有转备好他是不会写入应用中间的，所以节省资源），数据的读取过程依然在应用线程中完成

– 节省数据准备时间（因为Selector可以复用）

**5.网络编程 AIO（主要采用异步回调方式,他是异步的IO）**

 读完了再通知我（就会既不需要读，也不会需要写，就等待就行了）

 不会加快IO，只是在读完后进行通知（什么时候拿到通知什么时候处理，在没有拿到通知去做其他事情，节省时间）

 使用回调函数，进行业务处理

AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(PORT));

使用server上的accept方法

public abstract void accept(A attachment, CompletionHandlerhandler);

![70 8][]

read是从secket中读数据，因为是异步，所以会立即返回个future.，因此不会在等待读完才返回，不然不叫异步，异步是直接返回的。

write也是类似，写后会立即返回个future.

server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
     final ByteBuffer buffer = ByteBuffer.allocate(1024);
     public void completed(AsynchronousSocketChannel result, Object attachment) {
     System.out.println(Thread.currentThread().getName());
     Future<Integer> writeResult=null;
     try {
     buffer.clear();
     result.read(buffer).get(100, TimeUnit.SECONDS);//这里把异步有变成了类似同步与等待因为这里做了个阻塞。在这里也可以再来个回调函数去做一些处理
     buffer.flip();
     writeResult=result.write(buffer);
     } catch (InterruptedException | ExecutionException e) {
     e.printStackTrace();
     } catch (TimeoutException e) {
     e.printStackTrace();
     } finally {
     try {
     server.accept(null, this);//用于在做下一个请求操作，不想做完就程序就不在运行了
     writeResult.get();
     result.close();
     } catch (Exception e) {
     System.out.println(e.toString());
     }
     }
     }
     @Override
     public void failed(Throwable exc, Object attachment) {
     System.out.println("failed: " + exc);
     }
    });

**6、BIO、NIO与AIO对比：**

1.同步

例：买饭：自己亲自去饭馆买饭，这就是同步（自己处理IO读写）

2.异步

例：买饭：叫外卖送到家，这就是异步（IO读写委托给OS处理，需要将数据缓冲区地址和大小传给OS(饭名和地址)，OS需要支持异步IO操作API）

3.阻塞

例：办理业务：一直排队等待（调用会一直阻塞到读写完成才返回）

4.非阻塞

例：办理业务：抽号后就可以做其他事，如果你等不急，可以去问工作人员到你了没，如果没到你就不能办理业务。（如果不能读写，调用会马上返回，当IO事件分发器会通知可读写时再继续进行读写，不断循环直到读写完成）

BIO是同步阻塞的

### 伪异步IO：通过线程池机制优化了BIO模型 ###

NIO是同步非阻塞的

AIO是异步非阻塞的

由于NIO的读写过程依然在应用线程里完成，所以对于那些读写过程时间长的，NIO就不太适合。

而AIO的读写过程完成后才被通知，所以AIO能够胜任那些重量级，读写过程长的任务。

BIO是**服务器实现模式**：基于**原始的IO(输入输出流)**和**Socket**就可以编写一个最基本的BIO服务器（用于通信，走TCP协议；什么是TCP[https://www.cnblogs.com/buxiangxin/p/8336022.html][https_www.cnblogs.com_buxiangxin_p_8336022.html]；扩展**TCP长连接与短连接**[https://www.cnblogs.com/songjy2116/p/7750039.html][https_www.cnblogs.com_songjy2116_p_7750039.html]）；**一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，在JDK1.4出来之前使用的BIO**

Socket编程就是BIO，一个socket连接一个处理线程（这个线程负责这个Socket连接的一系列数据传输操作）。阻塞的原因在于：操作系统允许的线程数量是有限的，多个socket申请与服务端建立连接时，服务端不能提供相应数量的处理线程，没有分配到处理线程的连接就会阻塞等待或被拒绝。

BIO图解：

![70 9][]

### 伪异步IO ###

通过线程池机制优化了BIO模型

伪异步IO图解：

![70 10][]

### NIO模型 ###

同步非阻塞

服务器实现模式为一个请求一个线程，但客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。

NIO图解：

![70 11][]

### AIO模型 ###

异步非阻塞

服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS（操作系统）先完成了再通知服务器应用去启动线程进行处理，

注：AIO又称为NIO2.0，在JDK7才开始支持。

AIO流程图

![70 12][]

### BIO、伪异步、NIO和AIO模型的比较 ###

![70 13][]

BIO与NIO一个比较重要的不同，是我们使用BIO的时候往往会引入多线程，每个连接一个单独的线程；而NIO则是使用单线程或者只使用少量的多线程，每个连接共用一个线程。

BIO是一个连接一个线程。

NIO是一个请求一个线程。

AIO是一个有效请求一个线程。

**Java对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开始支持。

另外，I/O属于底层操作，需要操作系统支持，并发也需要操作系统的支持，所以性能方面不同操作系统差异会比较明显。

在高性能的I/O设计中，有两个比较著名的模式**Reactor和Proactor模式：详细介绍：[https://www.cnblogs.com/daoluanxiaozi/p/3274925.html，][https_www.cnblogs.com_daoluanxiaozi_p_3274925.html]**其中**Reactor模式用于同步I/O，**而**Proactor运用于异步I/O**操作。

在比较这两个模式之前，我们首先的搞明白几个概念，什么是阻塞和非阻塞，什么是同步和异步,同步和异步是针对应用程序和内核的交互而言的，同步指的是用户进程触发IO操作并等待或者轮询的去查看IO操作是否就绪，而异步是指用户进程触发IO操作以后便开始做自己的事情，而当IO操作已经完成的时候会得到IO完成的通知。而阻塞和非阻塞是针对于进程在访问数据的时候，根据IO操作的就绪状态来采取的不同方式，说白了是一种读取或者写入操作函数的实现方式，阻塞方式下读取或者写入函数将一直等待，而非阻塞方式下，读取或者写入函数会立即返回一个状态值。

一般来说I/O模型可以分为：同步阻塞，同步非阻塞，异步阻塞，异步非阻塞IO

**同步阻塞IO**：在此种方式下，用户进程在发起一个IO操作以后，必须等待IO操作的完成，只有当真正完成了IO操作以后，用户进程才能运行。JAVA传统的IO模型属于此种方式！

**同步非阻塞IO**:在此种方式下，用户进程发起一个IO操作以后边可返回做其它事情，但是用户进程需要时不时的询问IO操作是否就绪，这就要求用户进程不停的去询问，从而引入不必要的CPU资源浪费。其中目前JAVA的NIO就属于同步非阻塞IO。

**异步阻塞IO**：此种方式下是指应用发起一个IO操作以后，不等待内核IO操作的完成，等内核完成IO操作以后会通知应用程序，这其实就是同步和异步最关键的区别，同步必须等待或者主动的去询问IO是否完成，那么为什么说是阻塞的呢？因为此时是通过select系统调用来完成的，而select函数本身的实现方式是阻塞的，而采用select函数有个好处就是它可以同时监听多个文件句柄，从而提高系统的并发性！

**异步非阻塞IO**:在此种模式下，用户进程只需要发起一个IO操作然后立即返回，等IO操作真正的完成以后，应用程序会得到IO操作完成的通知，此时用户进程只需要对数据进行处理就好了，不需要进行实际的IO读写操作，因为真正的IO读取或者写入操作已经由内核完成了。目前Java中还没有支持此种IO模型。

参考：https://blog.csdn.net/baiye\_xing/article/details/73123753

https://blog.csdn.net/skiof007/article/details/52873421

https://www.cnblogs.com/ygj0930/p/6543960.html

[https_blog.csdn.net_gududedabai_article_details_80783994]: https://blog.csdn.net/gududedabai/article/details/80783994
[70]: /images/20220521/75b43299376247f4ad816871997b36f3.png
[https_www.cnblogs.com_jiduoduo_p_6397454.html]: https://www.cnblogs.com/jiduoduo/p/6397454.html
[70 1]: /images/20220521/fa53fe61c5344ffeb959e62578f00cd7.png
[70 2]: /images/20220521/ce70902fb29f43b3a2da2de3ceedb085.png
[70 3]: /images/20220521/81c0fe67024746f9bd75d027fd0be876.png
[70 4]: /images/20220521/f8e5ee8768574749a1ff970489ea58af.png
[70 5]: /images/20220521/045ee94160354864818a9931d48290fb.png
[70 6]: /images/20220521/67f5a83741534993aa27ab8cbd38e5d1.png
[70 7]: /images/20220521/fdad0ec5fd9f48a49f4488b328164309.png
[70 8]: /images/20220521/b378651510494d47960574e809ee9464.png
[https_www.cnblogs.com_buxiangxin_p_8336022.html]: https://www.cnblogs.com/buxiangxin/p/8336022.html
[https_www.cnblogs.com_songjy2116_p_7750039.html]: https://www.cnblogs.com/songjy2116/p/7750039.html
[70 9]: /images/20220521/b235f5770966428fb99d7f28d43daa34.png
[70 10]: /images/20220521/92474528d58941198467714ab0e65e04.png
[70 11]: /images/20220521/314f0d10f0ce4686987ed11fe2fe283b.png
[70 12]: /images/20220521/efc5ca753ff84842889ad58d2d8fab88.png
[70 13]: /images/20220521/e8a3163e075a455aab0433a93efff73d.png
[https_www.cnblogs.com_daoluanxiaozi_p_3274925.html]: https://www.cnblogs.com/daoluanxiaozi/p/3274925.html%EF%BC%8C