BIO，NIO，AIO区别

最新推荐文章于 2024-07-16 06:37:01 发布

小百菜

最新推荐文章于 2024-07-16 06:37:01 发布

阅读量2.3k

点赞数 5

分类专栏： java 文章标签： java nio aio bio

原文链接：https://mp.csdn.net/mp_blog/creation/editor?spm=1001.2101.3001.5352

版权

java 专栏收录该内容

105 篇文章 7 订阅

订阅专栏

1、BIO (Blocking IO)

同步阻塞IO，在 java.io 包下，也就是传统的io，平时就是使用的就是这个。

2、NIO (New IO或者Non-blocking IO)

同步非阻塞IO，在 java.nio 包下，NIO中的N可以理解为Non-blocking，所以nio也叫Non-blocking IO。

3、AIO (Asynchronous IO或者NIO2 )

异步非阻塞IO， AIO 也就是 NIO 2，是NIO 的改进版 NIO 2。
异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。

4、同步阻塞、同步非阻塞和异步非阻塞又代表什么意思呢？

举个生活中简单的例子，你妈妈让你烧水，小时候你比较笨啊，在哪里傻等着水开（同步阻塞）。
等你稍微再长大一点，你知道每次烧水的空隙可以去干点其他事，然后只需要时不时来看看水开了没有（同步非阻塞）。
后来，你们家用上了水开了会发出声音的壶，这样你就只需要听到响声后就知道水开了，在这期间你可以随便干自己的事情，你需要去倒水了（异步非阻塞）。

NIO 和 BIO 的比较

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

NIO	BIO
面向缓冲区（Buffer）	面向流（Stream）
非阻塞（Non Blocking IO）	阻塞IO(Blocking IO)
选择器（Selectors）

NIO 基本介绍

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

NIO 三大核心原理示意图

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

Buffer缓冲区

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。相比较直接对数组的操作，Buffer API更加容易操作和管理。

Channel（通道）

Java NIO的通道类似流，但又有些不同：既可以从通道中读取数据，又可以写数据到通道。但流的（input或output)读写通常是单向的。通道可以非阻塞读取和写入通道，通道可以支持读取或写入缓冲区，也支持异步地读写。

Selector选择器

Selector是一个Java NIO组件，可以能够检查一个或多个 NIO 通道，并确定哪些通道已经准备好进行读取或写入。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接，提高效率

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

NIO核心一：缓冲区(Buffer)

缓冲区（Buffer）

一个用于特定基本数据类型的容器。由 java.nio 包定义的，所有缓冲区都是 Buffer 抽象类的子类.。Java NIO 中的 Buffer 主要用于与 NIO 通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RGXxnvxp-1614494690619)(F:/typora/tupian/1614428062636.png)]

Buffer 类及其子类

Buffer 就像一个数组，可以保存多个相同类型的数据。根据数据类型不同，有以下 Buffer 常用子类：

ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer

上述 Buffer 类他们都采用相似的方法进行管理数据，只是各自管理的数据类型不同而已。都是通过如下方法获取一个 Buffer 对象：

static XxxBuffer allocate(int capacity) // 创建一个容量为capacity 的 XxxBuffer 对象

缓冲区的基本属性

Buffer 中的重要概念：

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

Buffer常见方法

Buffer clear() 清空缓冲区并返回对缓冲区的引用
Buffer flip() 将缓冲区的界限limit设置为当前位置，并将当前位置position设置为0
int capacity() 返回 Buffer 的 capacity 大小
boolean hasRemaining() 判断缓冲区中是否还有元素
int limit() 返回 Buffer 的界限(limit) 的位置
Buffer limit(int n) 将设置缓冲区界限为 n, 并返回一个具有新 limit 的缓冲区对象
Buffer mark() 对缓冲区设置标记
int position() 返回缓冲区的当前位置 position
Buffer position(int n) 将设置缓冲区的当前位置为 n , 并返回修改后的 Buffer 对象
int remaining() 返回 position 和 limit 之间的元素个数
Buffer reset() 将位置 position 转到以前设置的 mark 所在的位置
Buffer rewind() 将位置设为为 0， 取消设置的 mark

缓冲区的数据操作

Buffer 所有子类提供了两个用于数据操作的方法：get()put() 方法
取获取 Buffer中的数据
get() ：读取单个字节
get(byte[] dst)：批量读取多个字节到 dst 中
get(int index)：读取指定索引位置的字节(不会移动 position)
    
放到 入数据到 Buffer 中 中
put(byte b)：将给定单个字节写入缓冲区的当前位置
put(byte[] src)：将 src 中的字节写入缓冲区的当前位置
put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动 position)

使用Buffer读写数据一般遵循以下四个步骤：

1.写入数据到Buffer
2.调用flip()方法，转换读取模式
3.从Buffer中读取数据
4.调用buffer.clear()方法或者buffer.compact()方法清除缓冲区

案例演示 debug观察Buffer中pos、lim、cap的变化情况

package com.study.test;

import org.junit.Test;

import java.nio.ByteBuffer;


public class TestBuffer {
    @Test
    public void test3() {
        //分配直接缓冲区
        ByteBuffer buf = ByteBuffer.allocateDirect(1024);
        System.out.println(buf.isDirect());
    }

    @Test
    public void test2() {
        String str = "itheima";
        //创建一个容量为 1024 的 Buffer 对象
        ByteBuffer buf = ByteBuffer.allocate(1024);//java.nio.HeapByteBuffer[pos=0 lim=1024 cap=1024]

        buf.put(str.getBytes());//java.nio.HeapByteBuffer[pos=7 lim=1024 cap=1024]

        //调用 buffer.flip() 反转读写模式
        buf.flip();//java.nio.HeapByteBuffer[pos=0 lim=7 cap=1024]

        byte[] dst = new byte[buf.limit()];//数组长度为7
        buf.get(dst, 0, 2);//pos从0变为2，java.nio.HeapByteBuffer[pos=2 lim=7 cap=1024]
        System.out.println(new String(dst, 0, 2));//输出：it
        System.out.println(buf.position());//输出：2

        //mark() : 标记
        buf.mark();//标记记住当前的pos位置，java.nio.HeapByteBuffer[pos=2 lim=7 cap=1024]

        buf.get(dst, 2, 2);//java.nio.HeapByteBuffer[pos=4 lim=7 cap=1024]
        System.out.println(new String(dst, 2, 2));//输出：he
        System.out.println(buf.position());//输出：4

        //reset() : 恢复到 mark 的位置
        buf.reset();//pos恢复到mark标记的位置，java.nio.HeapByteBuffer[pos=2 lim=7 cap=1024]
        System.out.println(buf.position());//输出：2

        //判断缓冲区中是否还有剩余数据
        if (buf.hasRemaining()) {
            //获取缓冲区中可以操作的数量
            System.out.println(buf.remaining());//输出：5 = lim - pos
        }
    }

    @Test
    public void test1() {
        String str = "itheima";
        //1. 分配一个指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);//java.nio.HeapByteBuffer[pos=0 lim=1024 cap=1024]
        System.out.println("-----------------allocate()----------------");
        System.out.println(buf.position());//输出：0
        System.out.println(buf.limit());//输出：1024
        System.out.println(buf.capacity());//输出：1024

        //2. 利用 put() 存入数据到缓冲区中
        buf.put(str.getBytes());//java.nio.HeapByteBuffer[pos=7 lim=1024 cap=1024]
        System.out.println("-----------------put()----------------");
        System.out.println(buf.position());//输出：7
        System.out.println(buf.limit());//输出：1024
        System.out.println(buf.capacity());//输出：1024

        //3. 切换读取数据模式
        buf.flip();//java.nio.HeapByteBuffer[pos=0 lim=7 cap=1024]
        System.out.println("-----------------flip()----------------");
        System.out.println(buf.position());//输出：0
        System.out.println(buf.limit());//输出：7
        System.out.println(buf.capacity());//输出：1024

        //4. 利用 get() 读取缓冲区中的数据
        byte[] dst = new byte[buf.limit()];//数组长度为7
        buf.get(dst);//pos从0变为7，java.nio.HeapByteBuffer[pos=7 lim=7 cap=1024]
        System.out.println(new String(dst, 0, dst.length));//输出：itheima

        System.out.println("-----------------get()----------------");
        System.out.println(buf.position());//输出：7
        System.out.println(buf.limit());//输出：7
        System.out.println(buf.capacity());//输出：1024
        //5. rewind() : 可重复读
        buf.rewind();//pos从7变为0，java.nio.HeapByteBuffer[pos=0 lim=7 cap=1024]
        System.out.println("-----------------rewind()----------------");
        System.out.println(buf.position());//输出：0
        System.out.println(buf.limit());//输出：7
        System.out.println(buf.capacity());//输出：1024

        //6. clear() : 清空缓冲区. 但是缓冲区中的数据依然存在，但是处于“被遗忘”状态
        buf.clear();//并没有清空buf中的数据，lim从0变为cap容量长度1024, java.nio.HeapByteBuffer[pos=0 lim=1024 cap=1024]
        System.out.println("-----------------clear()----------------");
        System.out.println(buf.position());//输出：0
        System.out.println(buf.limit());//输出：1024
        System.out.println(buf.capacity());//输出：1024
        //get()读取一个字节
        System.out.println((char) buf.get()); //输出：i  。pos从0变为7，java.nio.HeapByteBuffer[pos=1 lim=1024 cap=1024]

    }

}

直接与非直接缓冲区

什么是直接内存与非直接内存

根据官方文档的描述：

byte byffer可以是两种类型，一种是基于直接内存（也就是非堆内存）；另一种是非直接内存（也就是堆内存）。对于直接内存来说，JVM将会在IO操作上具有更高的性能，因为它直接作用于本地系统的IO操作。而非直接内存，也就是堆内存中的数据，如果要作IO操作，会先从本进程内存复制到直接内存，再利用本地IO处理。

从数据流的角度，非直接内存是下面这样的作用链：

本地IO-->直接内存-->非直接内存-->直接内存-->本地IO

而直接内存是：

本地IO-->直接内存-->本地IO

很明显，在做IO处理时，比如网络发送大量数据时，直接内存会具有更高的效率。直接内存使用allocateDirect创建，但是它比申请普通的堆内存需要耗费更高的性能。不过，这部分的数据是在JVM之外的，因此它不会占用应用的内存。所以呢，当你有很大的数据要缓存，并且它的生命周期又很长，那么就比较适合使用直接内存。只是一般来说，如果不是能带来很明显的性能提升，还是推荐直接使用堆内存。字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。

使用场景

1 有很大的数据需要存储，它的生命周期又很长
2 适合频繁的IO操作，比如网络并发场景

NIO核心二：通道(Channel)

通道Channe概述

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

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

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

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

3、Channel 在 NIO 中是一个接口

public interface Channel extends Closeable{}

常用的Channel实现类

FileChannel：用于读取、写入、映射和操作文件的通道。
DatagramChannel：通过 UDP 读写网络中的数据通道。
SocketChannel：通过 TCP 读写网络中的数据。
ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。
【ServerSocketChanne 类似 ServerSocket , SocketChannel 类似 Socket】

FileChannel 类

获取通道的一种方式是对支持通道的对象调用getChannel() 方法。支持通道的类如下：

FileInputStream
FileOutputStream
RandomAccessFile
DatagramSocket
Socket
ServerSocket
获取通道的其他方式是使用 Files 类的静态方法 newByteChannel() 获取字节通道。或者通过通道的静态方法 open() 打开并返回指定通道

FileChannel的常用方法

int read(ByteBuffer dst) 从 Channel 中读取数据到  ByteBuffer
long  read(ByteBuffer[] dsts) 将  Channel 中的数据“分散”到  ByteBuffer[]
int  write(ByteBuffer src) 将  ByteBuffer 中的数据写入到  Channel
long write(ByteBuffer[] srcs) 将  ByteBuffer[] 中的数据“聚集”到  Channel
long position() 返回此通道的文件位置
FileChannel position(long p) 设置此通道的文件位置
long size() 返回此通道的文件的当前大小
FileChannel truncate(long s) 将此通道的文件截取为给定大小
void force(boolean metaData) 强制将所有对此通道的文件更新写入到存储设备中

案例1-本地文件写数据

需求：使用前面学习后的 ByteBuffer(缓冲) 和 FileChannel(通道)，将 “hello,黑马Java程序员！” 写入到 data.txt 中.
Buffer > Channel > File

package com.study.test;


import org.junit.Test;

import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

 
public class ChannelTest {
    @Test
    public void write() {
        try {
            // 1、字节输出流通向目标文件
            FileOutputStream fos = new FileOutputStream("d:/data01.txt");
            // 2、得到字节输出流对应的通道Channel
            FileChannel channel = fos.getChannel();
            // 3、分配缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put("hello,黑马Java程序员！".getBytes());
            // 4、把缓冲区切换成写出模式
            buffer.flip();
            channel.write(buffer);
            channel.close();
            System.out.println("写数据到文件中！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

案例2-本地文件读数据

需求：使用前面学习后的 ByteBuffer(缓冲) 和 FileChannel(通道)，将 data01.txt 中的数据读入到程序，并显示在控制台屏幕

File > Channel > Buffer

 @Test
    public void read() throws Exception {
        // 1、定义一个文件字节输入流与源文件接通
        FileInputStream is = new FileInputStream("d:/data01.txt");
        // 2、需要得到文件字节输入流的文件通道
        FileChannel channel = is.getChannel();
        // 3、定义一个缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        // 4、读取数据到缓冲区
        channel.read(buffer);
        buffer.flip();
        // 5、读取出缓冲区中的数据并输出即可
        //remaining() 返回 position 和 limit 之间的元素个数
        String rs = new String(buffer.array(),0,buffer.remaining());
        System.out.println(rs);

    }

案例3-使用Buffer完成文件复制

使用 FileChannel(通道) ，完成文件的拷贝。

@Test
    public void copy() throws Exception {
        // 源文件
        File srcFile = new File("D:\\壁纸.jpg");
        File destFile = new File("D:\\壁纸new.jpg");
        // 得到一个字节字节输入流
        FileInputStream fis = new FileInputStream(srcFile);
        // 得到一个字节输出流
        FileOutputStream fos = new FileOutputStream(destFile);
        // 得到的是文件通道
        FileChannel isChannel = fis.getChannel();
        FileChannel osChannel = fos.getChannel();
        // 分配缓冲区，初始化后lim和容量cap大小相同。
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        while (true) {
            // 必须先清空缓冲然后再写入数据到缓冲区
            buffer.clear();//事实上并没有清空buffer中的数据，只是将pos置为0，lim置为cap容量大小
            // 开始读取一次数据,返回数据长度
            int len = isChannel.read(buffer);//pos大小变为数据长度大小
            if (len == -1) {
                break;
            }
            if (len != 1024) {
                System.out.println();//断点观察
            }
            // 已经读取了数据 ，把缓冲区的模式切换成可读模式
            buffer.flip();//pos变为0，lim大小变为数据长度大小
            // 把数据写出到
            osChannel.write(buffer);//pos变为lim大小(即数据长度大小)
        }
        isChannel.close();
        osChannel.close();
        System.out.println("复制完成！");
    }

案例4-分散 (Scatter) 和聚集 (Gather)

分散读取（Scatter ）:是指把Channel通道的数据读入到多个缓冲区中去

聚集写入（Gathering ）是指将多个 Buffer 中的数据“聚集”到 Channel。

d:/1.txt文件内容为：123456789

    //分散和聚集
    @Test
    public void test() throws IOException {
        RandomAccessFile raf1 = new RandomAccessFile("d:/1.txt", "rw");
        //1. 获取通道
        FileChannel channel1 = raf1.getChannel();

        //2. 分配指定大小的缓冲区
        ByteBuffer buf1 = ByteBuffer.allocate(5);
        ByteBuffer buf2 = ByteBuffer.allocate(1024);

        //3. 分散读取
        ByteBuffer[] bufs = {buf1, buf2};
        channel1.read(bufs);

        for (ByteBuffer byteBuffer : bufs) {
            byteBuffer.flip();//pos变为0，lim大小变为数据长度大小
        }

        System.out.println(new String(bufs[0].array(), 0, bufs[0].limit()));//结果：12345
        System.out.println("-----------------");
        System.out.println(new String(bufs[1].array(), 0, bufs[1].limit()));//结果：6789

        //4. 聚集写入
        RandomAccessFile raf2 = new RandomAccessFile("d:/2.txt", "rw");
        FileChannel channel2 = raf2.getChannel();

        channel2.write(bufs);
    }

案例5-transferFrom()

从目标通道中去复制原通道数据

 @Test
    public void test02() throws Exception {
        // 1、字节输入管道
        FileInputStream is = new FileInputStream("d:/data01.txt");
        FileChannel isChannel = is.getChannel();
        // 2、字节输出流管道
        FileOutputStream fos = new FileOutputStream("d:/data03.txt");
        FileChannel osChannel = fos.getChannel();
        // 3、复制
        osChannel.transferFrom(isChannel,isChannel.position(),isChannel.size());
        isChannel.close();
        osChannel.close();
    }

案例6-transferTo()

把原通道数据复制到目标通道

    @Test
    public void test03() throws Exception {
        // 1、字节输入管道
        FileInputStream is = new FileInputStream("d:/data01.txt");
        FileChannel isChannel = is.getChannel();
        // 2、字节输出流管道
        FileOutputStream fos = new FileOutputStream("d:/data04.txt");
        FileChannel osChannel = fos.getChannel();
        // 3、复制
        isChannel.transferTo(isChannel.position() , isChannel.size() , osChannel);
        isChannel.close();
        osChannel.close();
    }

NIO核心三：选择器(Selector)

选择器(Selector)概述

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

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

选择器（Selector）的应用

创建 Selector ：通过调用 Selector.open() 方法创建一个 Selector。

Selector selector = Selector.open();

向选择器注册通道：SelectableChannel.register(Selector sel, int ops)

//1. 获取通道
ServerSocketChannel ssChannel = ServerSocketChannel.open();
//2. 切换非阻塞模式
ssChannel.configureBlocking(false);
//3. 绑定连接
ssChannel.bind(new InetSocketAddress(9898));
//4. 获取选择器
Selector selector = Selector.open();
//5. 将通道注册到选择器上, 并且指定“监听接收事件”
ssChannel.register(selector, SelectionKey.OP_ACCEPT);

当调用 register(Selector sel, int ops) 将通道注册选择器时，选择器对通道的监听事件，需要通过第二个参数 ops 指定。可以监听的事件类型（用可使用 SelectionKey 的四个常量表示）：

读 : SelectionKey.OP_READ （1）
写 : SelectionKey.OP_WRITE （4）
连接 : SelectionKey.OP_CONNECT （8）
接收 : SelectionKey.OP_ACCEPT （16）
若注册时不止监听一个事件，则可以使用“位或”操作符连接。

int interestSet = SelectionKey.OP_READ|SelectionKey.OP_WRITE

NIO非阻塞式网络通信原理分析

Selector 示意图和特点说明

Selector可以实现：一个 I/O 线程可以并发处理 N 个客户端连接和读写操作，这从根本上解决了传统同步阻塞 I/O 一连接一线程模型，架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。

1、当客户端连接服务端时，服务端会通过 ServerSocketChannel 得到 SocketChannel：1. 获取通道

 ServerSocketChannel ssChannel = ServerSocketChannel.open();

2、切换非阻塞模式

 ssChannel.configureBlocking(false);

3、绑定连接，设置服务端监听端口

 ssChannel.bind(new InetSocketAddress(9999));

4、获取选择器

Selector selector = Selector.open();

5、将通道注册到选择器上, 并且指定“监听接收事件”

ssChannel.register(selector, SelectionKey.OP_ACCEPT);

6、轮询式的获取选择器上已经“准备就绪”的事件

//轮询式的获取选择器上已经“准备就绪”的事件
 while (selector.select() > 0) {
        System.out.println("轮一轮");
        //7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
        Iterator<SelectionKey> it = selector.selectedKeys().iterator();
        while (it.hasNext()) {
            //8. 获取准备“就绪”的是事件
            SelectionKey sk = it.next();
            //9. 判断具体是什么事件准备就绪
            if (sk.isAcceptable()) {
                //10. 若“接收就绪”，获取客户端连接
                SocketChannel sChannel = ssChannel.accept();
                //11. 切换非阻塞模式
                sChannel.configureBlocking(false);
                //12. 将该通道注册到选择器上
                sChannel.register(selector, SelectionKey.OP_READ);
            } else if (sk.isReadable()) {
                //13. 获取当前选择器上“读就绪”状态的通道
                SocketChannel sChannel = (SocketChannel) sk.channel();
                //14. 读取数据
                ByteBuffer buf = ByteBuffer.allocate(1024);
                int len = 0;
                while ((len = sChannel.read(buf)) > 0) {
                    buf.flip();
                    System.out.println(new String(buf.array(), 0, len));
                    buf.clear();
                }
            }
            //15. 取消选择键 SelectionKey
            it.remove();
        }
    }
}

客户端流程

1、获取通道

SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999));

2、切换非阻塞模式

sChannel.configureBlocking(false);

3、分配指定大小的缓冲区

 ByteBuffer buf = ByteBuffer.allocate(1024);

4、发送数据给服务端

Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
	String str = scan.nextLine();
	buf.put((new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(System.currentTimeMillis())
			+ "\n" + str).getBytes());
	buf.flip();
	sChannel.write(buf);
	buf.clear();
}
//关闭通道
sChannel.close();

NIO非阻塞式网络通信入门案例

需求：服务端接收客户端的连接请求，并接收多个客户端发送过来的事件。

代码案例（这个案例没有实现服务端响应客户端）

服务端

package com.study.test;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;


public class Server {
    public static void main(String[] args) throws IOException {
        //1. 获取通道
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        //2. 切换非阻塞模式
        ssChannel.configureBlocking(false);
        //3. 绑定连接
        ssChannel.bind(new InetSocketAddress(9999));
        //4. 获取选择器
        Selector selector = Selector.open();
        //5. 将通道注册到选择器上, 并且指定“监听接收事件”
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);

        //6. 轮询式的获取选择器上已经“准备就绪”的事件
        // selector.select() 方法会阻塞，直到有客户端连接进来，或者客户端SocketChannel发送数据过来
        while (selector.select() > 0) {
            System.out.println("轮一轮");
            //7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
                //8. 获取准备“就绪”的是事件
                SelectionKey sk = it.next();
                //9. 判断具体是什么事件准备就绪
                if (sk.isAcceptable()) {
                    //10. 若“接收就绪”，获取客户端连接
                    SocketChannel sChannel = ssChannel.accept();
                    //11. 切换非阻塞模式
                    sChannel.configureBlocking(false);
                    //12. 将该通道注册到选择器上
                    sChannel.register(selector, SelectionKey.OP_READ);
                } else if (sk.isReadable()) {
                    //13. 获取当前选择器上“读就绪”状态的通道
                    SocketChannel sChannel = (SocketChannel) sk.channel();
                    //14. 读取数据
                    ByteBuffer buf = ByteBuffer.allocate(1024);//[pos=0 lim=1024 cap=1024]
                    int len;//数据长度
                    while ((len = sChannel.read(buf)) > 0) {//[pos=数据长度 lim=1024 cap=1024]
                        buf.flip();//[pos=0 lim=数据长度 cap=1024]
                        System.out.println(new String(buf.array(), 0, len));
                        buf.clear();
                    }
                }
                //15. 取消选择键 SelectionKey
                it.remove();
            }
        }
    }
}

客户端

package com.study.test;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.text.SimpleDateFormat;
import java.util.Scanner;

public class Client {

    public static void main(String[] args) throws Exception {
        //1. 获取通道
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999));
        //2. 切换非阻塞模式
        sChannel.configureBlocking(false);
        //3. 分配指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        //4. 发送数据给服务端
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) {
            String str = scan.nextLine();
            buf.put((new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(System.currentTimeMillis())
                    + "\n" + str).getBytes());
            buf.flip();
            sChannel.write(buf);
            buf.clear();
        }
        //5. 关闭通道
        sChannel.close();
    }
}

这个案例启动了一个 Selector 选择器，将服务端通道 ServerSocketChannel 注册到 Selector 选择器上，并绑定一个接收 OP_ACCEPT 事件
然后调用 Selector 选择器select()方法，这个方法是阻塞，直到有 OP_ACCEPT事件(有客户端SocketChannel 连接请求)，select()方法不再阻塞，继续往下执行，
接收到客户端SocketChannel 连接请求后，将这个SocketChannel 再注册到 Selector 选择器上，并绑定一个读 OP_READ 事件，以后选择器就可以监听到客户端发送过来的数据
每次 Selector 选择器接收到事件驱动后要记得移除这个驱动事件。

整个过程，Selector 选择器，在Channel通道之间通过Channel通道各种绑定的事件驱动来回切换。

NIO 网络编程应用实例-群聊系统

目标

需求:进一步理解 NIO 非阻塞网络编程机制，实现多人群聊

编写一个 NIO 群聊系统，实现客户端与客户端的通信需求（非阻塞）
服务器端：可以监测用户上线，离线，并实现消息转发功能
客户端：通过 channel 可以无阻塞发送消息给其它所有客户端用户，同时可以接受其它客户端用户通过服务端转发来的消息

服务端代码实现

package com.study.chat;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class Server {
    //定义属性
    private Selector selector;
    private ServerSocketChannel ssChannel;
    private static final int PORT = 9999;

    //构造器
    //初始化工作
    public Server() {
        try {
            // 1、获取通道
            ssChannel = ServerSocketChannel.open();
            // 2、切换为非阻塞模式
            ssChannel.configureBlocking(false);
            // 3、绑定连接的端口
            ssChannel.bind(new InetSocketAddress(PORT));
            // 4、获取选择器Selector
            selector = Selector.open();
            // 5、将通道都注册到选择器上去，并且开始指定监听接收事件
            ssChannel.register(selector, SelectionKey.OP_ACCEPT);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        //创建服务器对象
        Server groupChatServer = new Server();
        groupChatServer.listen();
    }

    //监听
    public void listen() {
        System.out.println("监听线程: " + Thread.currentThread().getName());
        try {
            while (selector.select() > 0) {
                System.out.println("开始一轮事件处理~~~");
                // 7、获取选择器中的所有注册的通道中已经就绪好的事件
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                // 8、开始遍历这些准备好的事件
                while (it.hasNext()) {
                    // 提取当前这个事件
                    SelectionKey sk = it.next();
                    // 9、判断这个事件具体是什么
                    if (sk.isAcceptable()) {
                        // 10、直接获取当前接入的客户端通道
                        SocketChannel schannel = ssChannel.accept();
                        // 11 、切换成非阻塞模式
                        schannel.configureBlocking(false);
                        // 12、将本客户端通道注册到选择器
                        System.out.println(schannel.getRemoteAddress() + " 上线 ");
                        schannel.register(selector, SelectionKey.OP_READ);
                        //提示
                    } else if (sk.isReadable()) {
                        //处理读 (专门写方法..)
                        readData(sk);
                    }
                    it.remove(); // 处理完毕之后需要移除当前事件
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        }
    }

    //读取客户端消息
    private void readData(SelectionKey key) {
        //取到关联的channle
        SocketChannel channel = null;
        try {
            //得到channel
            channel = (SocketChannel) key.channel();

            // 与对方约定前3个字节为消息内容长度
            // 3个字节(1个字节8位二进制)：表示一条消息内容最大长度 2^24-1 = 16777215K ≈ 16M。如果约定4个字节一条消息内容最大长度为4G。

            // 首先取出前3个字节，计算消息内容的长度
            ByteBuffer headBuf = ByteBuffer.allocate(3);
            channel.read(headBuf);
            headBuf.flip();//pos变为0，lim大小变为数据长度大小
            // 约定前3个字节为消息内容长度
            byte first = headBuf.get();
            byte second = headBuf.get();
            byte third = headBuf.get();
            // 消息内容长度
            int length = (first << 16) + (second << 8) + third;
            //创建buffer
            ByteBuffer buf = ByteBuffer.allocate(1024);//[pos=0 lim=1024 cap=1024]
            int len;//数据长度
            StringBuilder msg = new StringBuilder();
            for (int i = 0; i < length; i += len) {
                buf.clear();//事实上并没有清空buffer中的数据，只是将pos置为0，lim置为cap容量大小 [pos=0 lim=1024 cap=1024]
                // 开始读取一次数据,返回数据长度
                len = channel.read(buf);//pos变为数据长度大小 [pos=数据长度 lim=1024 cap=1024]
                if (len == -1) {
                    break;
                }
                if (len == 0) {
                    Thread.sleep(100);
                } else {
                    buf.flip();//pos变为0，lim大小变为数据长度大小 [pos=0 lim=数据长度 cap=1024]
                    // 从buffer中取出数据
                    msg.append(new String(buf.array(), 0, len));
                }
            }

            //输出该消息
            System.out.println("form 客户端: " + msg);

            // 到这里就可以将接收到的消息内容放入 MQ 或者开启一个子线程来处理消息内容了。

            //向其它的客户端转发消息(去掉自己), 专门写一个方法来处理
            sendInfoToOtherClients(msg.toString(), channel);
        } catch (Exception e) {
            try {
                System.out.println(channel.getRemoteAddress() + " 离线了..");
                e.printStackTrace();
                //取消注册
                key.cancel();
                //关闭通道
                channel.close();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }

    //转发消息给其它客户(通道)
    private void sendInfoToOtherClients(String msg, SocketChannel self) throws IOException {
        System.out.println("服务器转发消息中...");
        System.out.println("服务器转发数据给客户端线程: " + Thread.currentThread().getName());
        //遍历 所有注册到selector 上的 SocketChannel,并排除 self
        for (SelectionKey key : selector.keys()) {
            try {
                //通过 key  取出对应的 SocketChannel
                Channel targetChannel = key.channel();
                //排除自己
                if (targetChannel instanceof SocketChannel && targetChannel != self) {
                    //转型
                    SocketChannel dest = (SocketChannel) targetChannel;
                    //将msg 存储到buffer
                    ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                    // 首先需要计算消息内容的长度
                    int length = buffer.limit();

                    // 与对方约定前3个字节为消息内容长度
                    // 3个字节(1个字节8位二进制)：表示一条消息内容最大长度 2^24-1 = 16777215K ≈ 16M。如果约定4个字节一条消息内容最大长度为4G。
                    ByteBuffer headBuf = ByteBuffer.allocate(3);
                    // int是4个字节32位，byte是1个字节8位，int类型转化为byte类型时会出现位丢失情况，即将int的低8位作为byte类型的值，高8位丢弃。
                    headBuf.put((byte) (length >> 16));
                    headBuf.put((byte) (length >> 8));
                    headBuf.put((byte) length);
                    headBuf.flip();//pos变为0，lim大小变为数据长度大小
                    // 将消息的长度优先发送出去，消息长度约定占3个字节
                    dest.write(headBuf);
                    // Thread.sleep(10000);//模拟粘包拆包

                    // 发送消息内容
                    dest.write(buffer);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}

客户端代码实现

package com.study.chat;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;

public class Client {
    //定义相关的属性
    private final String HOST = "127.0.0.1"; // 服务端的ip
    private final int PORT = 9999; //服务端的端口
    private Selector selector;
    private SocketChannel socketChannel;
    private String username;

    //构造器, 完成初始化工作
    public Client() throws IOException {
        selector = Selector.open();
        //连接服务器
        socketChannel = socketChannel.open(new InetSocketAddress(HOST, PORT));
        //设置非阻塞
        socketChannel.configureBlocking(false);
        //将channel 注册到selector
        socketChannel.register(selector, SelectionKey.OP_READ);
        //得到username
        username = socketChannel.getLocalAddress().toString().substring(1);
        System.out.println(username + " is ok...");
    }

    public static void main(String[] args) throws Exception {
        //启动我们客户端
        Client chatClient = new Client();

        // Selector选择器，会阻塞线程，需要单独开一个子线程来完成
        new Thread() {
            public void run() {
                chatClient.readInfo();
            }
        }.start();

        //从控制台接收数据，发送数据给服务器端
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            chatClient.sendInfo(s);
        }
    }

    //向服务器发送消息
    public void sendInfo(String info) {
        info = username + " 说：" + info;
        try {
            ByteBuffer buffer = ByteBuffer.wrap(info.getBytes());
            // 首先需要计算消息内容的长度
            int length = buffer.limit();

            // 与对方约定前3个字节为消息内容长度
            // 3个字节(1个字节8位二进制)：表示一条消息内容最大长度 2^24-1 = 16777215K ≈ 16M。如果约定4个字节一条消息内容最大长度为4G。
            ByteBuffer headBuf = ByteBuffer.allocate(3);
            // int是4个字节32位，byte是1个字节8位，int类型转化为byte类型时会出现位丢失情况，即将int的低8位作为byte类型的值，高8位丢弃。
            headBuf.put((byte) (length >> 16));
            headBuf.put((byte) (length >> 8));
            headBuf.put((byte) length);
            headBuf.flip();//pos变为0，lim大小变为数据长度大小
            // 将消息的长度优先发送出去，消息长度约定占3个字节
            socketChannel.write(headBuf);
            Thread.sleep(10000);//模拟粘包拆包

            // 发送消息内容
            socketChannel.write(buffer);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //读取从服务器端回复的消息
    public void readInfo() {
        try {
            while (selector.select() > 0) {//有可以用的通道
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    if (key.isReadable()) {
                        //处理读 (专门写方法..)
                        readData(key);
                    }
                }
                iterator.remove(); //删除当前的selectionKey, 防止重复操作
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //读取客户端消息
    private void readData(SelectionKey key) {
        //取到关联的channle
        SocketChannel channel = null;
        try {
            //得到channel
            channel = (SocketChannel) key.channel();

            // 与对方约定前3个字节为消息内容长度
            // 3个字节(1个字节8位二进制)：表示一条消息内容最大长度 2^24-1 = 16777215K ≈ 16M。如果约定4个字节一条消息内容最大长度为4G。

            // 首先取出前3个字节，计算消息内容的长度
            ByteBuffer headBuf = ByteBuffer.allocate(3);
            channel.read(headBuf);
            headBuf.flip();//pos变为0，lim大小变为数据长度大小
            // 约定前3个字节为消息内容长度
            byte first = headBuf.get();
            byte second = headBuf.get();
            byte third = headBuf.get();
            // 消息内容长度
            int length = (first << 16) + (second << 8) + third;
            //创建buffer
            ByteBuffer buf = ByteBuffer.allocate(1024);//[pos=0 lim=1024 cap=1024]
            int len;//数据长度
            StringBuilder msg = new StringBuilder();
            for (int i = 0; i < length; i += len) {
                buf.clear();//事实上并没有清空buffer中的数据，只是将pos置为0，lim置为cap容量大小 [pos=0 lim=1024 cap=1024]
                // 开始读取一次数据,返回数据长度
                len = channel.read(buf);//pos变为数据长度大小 [pos=数据长度 lim=1024 cap=1024]
                if (len == -1) {
                    break;
                }
                if (len == 0) {
                    Thread.sleep(100);
                } else {
                    buf.flip();//pos变为0，lim大小变为数据长度大小 [pos=0 lim=数据长度 cap=1024]
                    // 从buffer中取出数据
                    msg.append(new String(buf.array(), 0, len));
                }
            }

            //输出该消息
            System.out.println(msg);

            // 到这里就可以将接收到的消息内容放入 MQ 或者开启一个子线程来处理消息内容了。

        } catch (Exception e) {
            try {
                System.out.println(channel.getRemoteAddress() + " 离线了..");
                e.printStackTrace();
                //取消注册
                key.cancel();
                //关闭通道
                channel.close();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }

}

可以参考我另一篇传统的socket的处理方式：Java网络编程Socket_java中socket的用法_小百菜的博客-CSDN博客

上面的服务端和客户端方法 readData() 被我改造成阻塞式的了， readData()方法里面的 for 循环是一个阻塞方法如果 len为0 会一直循环导致整个方法阻塞。这样有违背nio的初衷。
这样做跟传统的socket没有区别了，传统的io的read方法会阻塞，而nio的Buffer缓冲区read方法不会阻塞，nio的read方法会立即返回然后去做其他事，而不是像我这样一直在for循环中等待，这样跟阻塞没什么区别，由于时间有限，先搁置后面有空再完善。

初步改善逻辑是，首先知道有很多 SocketChannel 通道，选择器Selector在这些通道之间来回切换，
设置一个全局变量，以SocketChannel 为key，值为当前SocketChannel 中已经取到的消息内容，消息长度，剩余消息长度等进度。
每次切换到某一个SocketChannel 通道时，先从全局变量取出上次的进度，继续取数，取数完毕就从全局变量中去除当前SocketChannel 的key。

JAVA AIO深入剖析

AIO编程

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

    BIO                   NIO                              AIO        
Socket                SocketChannel                    AsynchronousSocketChannel
ServerSocket          ServerSocketChannel	       AsynchronousServerSocketChannel

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

即可以理解为，read/write方法都是异步的，完成后会主动调用回调函数。在JDK1.7中，这部分内容被称作NIO.2，主要在Java.nio.channels包下增加了下面四个异步通道：

	AsynchronousSocketChannel
	AsynchronousServerSocketChannel
	AsynchronousFileChannel
	AsynchronousDatagramChannel

BIO,NIO,AIO课程总结

BIO、NIO、AIO：

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

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