20200930 3. Java NIO 编程

Java NIO 编程

基本介绍

Java NIO 全称 java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)，是同步非阻塞的
NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写。【基本案例】
NIO 有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector(选择器)
NIO是 面向缓冲区（或者说是面向块） 编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络
Java NIO的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。【后面有案例说明】
通俗理解：NIO是可以做到用一个线程来处理多个操作的。假设有10000个请求过来,根据实际情况，可以分配50或者100个线程来处理。不像之前的阻塞IO那样，非得分配10000个。
HTTP2.0 使用了多路复用的技术，做到同一个连接并发处理多个请求，而且并发请求的数量比 HTTP1.1 大了好几个数量级。

NIO 和 BIO 的比较

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

NIO 三大核心

NIO 三大核心原理示意图

Selector 、 Channel 和 Buffer 的关系图(简单版)

关系图的说明:

每个 Channel 都会对应一个 Buffer
Selector 对应一个线程，一个线程对应多个 Channel (连接)
该图反应了有三个 Channel 注册到该 Selector //程序
程序切换到哪个 Channel 是由事件决定的, Event 就是一个重要的概念
Selector 会根据不同的事件，在各个通道上切换
Buffer 就是一个内存块，底层是有一个数组
数据的读取写入是通过 Buffer, 这个和 BIO 不同, BIO 中要么是输入流，或者是输出流, 不能双向，但是NIO的 Buffer 是可以读也可以写, 需要 flip 方法切换，
Channel 是双向的，可以反映底层操作系统的情况，比如Linux ，底层的操作系统通道就是双向的。

缓冲区(Buffer)

基本介绍

缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象(含数组)，该对象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer，如图: 【后面举例说明】

Buffer 的基本使用

public class NioBasic {
    public static void main(String[] args) {
        //指定buffer长度
        IntBuffer buffer = IntBuffer.allocate(5);
        Random random1 = new Random();
        //加入随机数
        for (int i = 0; i < buffer.capacity(); i++) {
            buffer.put(random1.nextInt(1000));
        }
        
        //将buffer转换一下，读写切换
        buffer.flip();
        
        //读取
        while (buffer.hasRemaining()) {
            System.out.println(buffer.get());
        }
    }
}

Buffer 类及其子类

在 NIO 中，Buffer 是一个顶层父类，它是一个抽象类，常用 Buffer 子类一览：

ByteBuffer，存储字节数据到缓冲区
ShortBuffer，存储短整型数据到缓冲区
CharBuffer，存储字符数据到缓冲区
IntBuffer，存储整数数据到缓冲区
LongBuffer，存储长整型数据到缓冲区
DoubleBuffer，存储小数到缓冲区
FloatBuffer，存储小数到缓冲区

Buffer 类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息：

private int mark = -1;
private int position = 0;
private int limit;
private int capacity;

属性	描述
Capacity	容量，即可以容纳的最大数据量；在缓冲区创建时被设定并且不能改变
Limit	表示缓冲区的当前终点，不能对缓冲区超过极限的位置进行读写操作。且极限是可以修改的
Position	位置，下一个要被读或写的元素的索引，每次读写缓冲区数据时都会改变改值，为下次读写作准备
Mark	标记

Buffer 类相关方法一览：

public abstract class Buffer {
    //JDK1.4时，引入的api
    public final int capacity()//返回此缓冲区的容量
    public final int position()//返回此缓冲区的位置
    public final Buffer position (int newPositio)//设置此缓冲区的位置
    public final int limit()//返回此缓冲区的限制
    public final Buffer limit (int newLimit)//设置此缓冲区的限制
    public final Buffer mark()//在此缓冲区的位置设置标记
    public final Buffer reset()//将此缓冲区的位置重置为以前标记的位置
    public final Buffer clear()//清除此缓冲区, 即将各个标记恢复到初始状态，但是数据并没有真正擦除, 后面操作会覆盖
    public final Buffer flip()//反转此缓冲区
    public final Buffer rewind()//重绕此缓冲区
    public final int remaining()//返回当前位置与限制之间的元素数
    public final boolean hasRemaining()//告知在当前位置和限制之间是否有元素
    public abstract boolean isReadOnly();//告知此缓冲区是否为只读缓冲区
 
    //JDK1.6时引入的api
    public abstract boolean hasArray();//告知此缓冲区是否具有可访问的底层实现数组
    public abstract Object array();//返回此缓冲区的底层实现数组
    public abstract int arrayOffset();//返回此缓冲区的底层实现数组中第一个缓冲区元素的偏移量
    public abstract boolean isDirect();//告知此缓冲区是否为直接缓冲区
}

从前面可以看出对于 Java 中的基本数据类型(boolean除外)，都有一个 Buffer 类型与之相对应，最常用的自然是 ByteBuffer 类（二进制数据），该类的主要方法如下：

public abstract class ByteBuffer {
    //缓冲区创建相关api
    public static ByteBuffer allocateDirect(int capacity)//创建直接缓冲区
    public static ByteBuffer allocate(int capacity)//设置缓冲区的初始容量
    public static ByteBuffer wrap(byte[] array)//把一个数组放到缓冲区中使用
    //构造初始化位置offset和上界length的缓冲区
    public static ByteBuffer wrap(byte[] array,int offset, int length)
     //缓存区存取相关API
    public abstract byte get();//从当前位置position上get，get之后，position会自动+1
    public abstract byte get (int index);//从绝对位置get
    public abstract ByteBuffer put (byte b);//从当前位置上添加，put之后，position会自动+1
    public abstract ByteBuffer put (int index, byte b);//从绝对位置上put
}

通道(Channel)

基本介绍

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

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

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

Channel 在NIO中是一个接口：

public interface Channel extends Closeable{}

常用的 Channel 类有：

FileChannel
DatagramChannel
ServerSocketChannel
SocketChannel

【ServerSocketChannel 类似 ServerSocket , SocketChannel 类似 Socket】

FileChannel 用于文件的数据读写
DatagramChannel 用于 UDP 的数据读写
ServerSocketChannel 和 SocketChannel 用于 TCP 的数据读写。

FileChannel 类

FileChannel 主要用来对本地文件进行 IO 操作，常见的方法有：

// 从通道读取数据并放到缓冲区中
public int read(ByteBuffer dst) 
// 把缓冲区的数据写到通道中
public int write(ByteBuffer src)
// 从目标通道中复制数据到当前通道
public long transferFrom(ReadableByteChannel src, long position, long count)
// 把数据从当前通道复制给目标通道
public long transferTo(long position, long count, WritableByteChannel target)

应用实例1-本地文件写数据

实例要求:

使用前面学习后的ByteBuffer(缓冲) 和 FileChannel(通道)，将 "hello,尚硅谷" 写入到file01.txt 中
文件不存在就创建
代码演示

public class NIOFileOper01 {

    public static void main(String[] args) throws Exception {

        String str = "hello,尚硅谷~";
        FileOutputStream fos = new FileOutputStream("d:\\file01.txt");
        //使用FileChannel 通道
        //fos.getChannle 返回的是 FileChanel 的实现子类 FileChannelImpl
        //可以追下源代码
        FileChannel fc = fos.getChannel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        /*
         *NIO 中的通道是从输出流对象里通过 getChannel 方法获取到的，该通道是双向的，既可
         *以读，又可以写。在往通道里写数据之前，必须通过 put 方法把数据存到 ByteBuffer 中，然
         *后通过通道的 write 方法写数据。在 write 之前，需要调用 flip 方法翻转缓冲区，把内部重置
         *到初始位置，这样在接下来写数据时才能把所有数据写到通道里
         */
        buffer.put(str.getBytes());
        buffer.flip();
        fc.write(buffer);
        fos.close();
    }
}

应用实例2-本地文件读数据

实例要求:

使用前面学习后的ByteBuffer(缓冲) 和 FileChannel(通道)，将 file01.txt 中的数据读入到程序，并显示在控制台屏幕
假定文件已经存在
代码演示

public class NIOFileOper02 {

    public static void main(String[] args) throws Exception {
        File file = new File("d:\\file01.txt");
        FileInputStream fis = new FileInputStream(file);
        //说明:
		/*
		 * 从输入流中获得一个通道，然后提供 ByteBuffer 缓冲区，该缓冲区的初始容量
		和文件的大小一样，最后通过通道的 read 方法把数据读取出来并存储到了 ByteBuffer 中
		 */
        FileChannel fc = fis.getChannel();
        ByteBuffer buffer = ByteBuffer.allocate((int) file.length());
        //该通道可以写操作，也可以读操作

        fc.read(buffer);
        System.out.print(new String(buffer.array()));
        fis.close();
    }
}

应用实例3-使用一个Buffer完成文件读取

实例要求:

使用 FileChannel(通道) 和方法 read , write，完成文件的拷贝
拷贝一个文本文件 1.txt , 放在项目下即可
代码演示

public class NIOFileOper03 {

    public static void main(String[] args) throws Exception {
        FileInputStream fileInputStream = new FileInputStream("1.txt");
        FileChannel channel01 = fileInputStream.getChannel();

        FileOutputStream fileOutputStream = new FileOutputStream("2.txt");
        FileChannel channel02 = fileOutputStream.getChannel();

        ByteBuffer byteBuffer = ByteBuffer.allocate(10);

        while (true) {
            byteBuffer.clear();

            int read = channel01.read(byteBuffer);
            System.out.println("read = " + read);
            if (read == -1) {
                break;
            }

            byteBuffer.flip();
            channel02.write(byteBuffer);
        }

        fileInputStream.close();
        fileOutputStream.close();

    }
}

应用实例4-拷贝文件 transferFrom 方法

实例要求:

使用 FileChannel(通道) 和方法 transferFrom ，完成文件的拷贝
拷贝一张图片
代码演示

public class NIOFileCopy {

    public static void main(String[] args) throws Exception {

        FileInputStream fis = new FileInputStream("image001.png");
        FileOutputStream fos = new FileOutputStream("imageCopy001.png");

        FileChannel sourCh = fis.getChannel();
        FileChannel destCh = fos.getChannel();

        destCh.transferFrom(sourCh, 0, sourCh.size());

        sourCh.close();
        destCh.close();
        fis.close();
        fos.close();

        System.out.println("图片拷贝完毕~~");
    }

}

关于 Buffer 和 Channel 的注意事项和细节

ByteBuffer 支持类型化的 put 和 get, put 放入的是什么数据类型，get 就应该使用相应的数据类型来取出，否则可能有 BufferUnderflowException 异常。
可以将一个普通 Buffer 转成只读 Buffer 。
NIO 还提供了 MappedByteBuffer， 可以让文件直接在内存（堆外的内存）中进行修改，而如何同步到文件由 NIO 来完成。
前面我们讲的读写操作，都是通过一个Buffer 完成的，NIO 还支持通过多个 Buffer (即 Buffer 数组) 完成读写操作，即 Scattering 和 Gathering。

Selector(选择器)

基本介绍

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

特点再说明:

Netty 的 IO 线程 NioEventLoop 聚合了 Selector(选择器，也叫多路复用器)，可以同时并发处理成百上千个客户端连接。
当线程从某客户端 Socket 通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。
线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入和输出通道。
由于读写操作都是非阻塞的，这就可以充分提升 IO 线程的运行效率，避免由于频繁 I/O 阻塞导致的线程挂起。
一个 I/O 线程可以并发处理 N 个客户端连接和读写操作，这从根本上解决了传统同步阻塞 I/O 一连接一线程模型，架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。

Selector类相关方法

Selector 类是一个抽象类, 常用方法和说明如下:

public abstract class Selector implements Closeable { 
    //得到一个选择器对象
    public static Selector open();
    
    //监控所有注册的通道，当其中有 IO 操作可以进行时，将对应的 SelectionKey 加入到内部集合中并返回，参数用来设置超时时间
    public int select(long timeout);
    
    //从内部集合中得到所有的 SelectionKey	
    public Set<SelectionKey> selectedKeys();
}

注意事项

NIO中的 ServerSocketChannel 功能类似 ServerSocket，SocketChannel 功能类似 Socket

selector 相关方法说明

//阻塞
selector.select();

//阻塞1000毫秒，在1000毫秒后返回
selector.select(1000);

//唤醒selector
selector.wakeup();

//不阻塞，立马返还
selector.selectNow();

NIO 非阻塞网络编程原理分析

NIO 非阻塞网络编程相关的(Selector、SelectionKey、ServerScoketChannel和SocketChannel) 关系梳理图：

图的说明：

当客户端连接时，会通过 ServerSocketChannel 得到 SocketChannel
Selector 进行监听 select 方法, 返回有事件发生的通道的个数.
将 socketChannel 注册到 Selector 上，register(Selector sel, int ops), 一个 selector 上可以注册多个 SocketChannel
注册后返回一个 SelectionKey, 会和该 Selector 关联(集合)
进一步得到各个 SelectionKey (有事件发生)
在通过 SelectionKey 反向获取 SocketChannel , 方法 channel()
可以通过得到的 channel , 完成业务处理

NIO 非阻塞网络编程快速入门

案例要求:

编写一个 NIO 入门案例，实现服务器端和客户端之间的数据简单通讯（非阻塞）
目的：理解NIO非阻塞网络编程机制

服务器端

@Slf4j
public class NIOServer {
    public static void main(String[] args) throws Exception {

        //创建ServerSocketChannel -> ServerSocket

        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        //得到一个Selecor对象
        Selector selector = Selector.open();

        //绑定一个端口6666, 在服务器端监听
        serverSocketChannel.socket().bind(new InetSocketAddress(6666));
        //设置为非阻塞
        serverSocketChannel.configureBlocking(false);

        //把 serverSocketChannel 注册到  selector 关心 事件为 OP_ACCEPT
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        log.info("注册后的selectionkey 数量=" + selector.keys().size()); // 1


        //循环等待客户端连接
        while (true) {

            //这里我们等待1秒，如果没有事件发生, 返回
            if (selector.select(1000) == 0) { //没有事件发生
                log.info("服务器等待了1秒，无连接");
                continue;
            }

            //如果返回的>0, 就获取到相关的 selectionKey集合
            //1.如果返回的>0， 表示已经获取到关注的事件
            //2. selector.selectedKeys() 返回关注事件的集合
            //   通过 selectionKeys 反向获取通道
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            log.info("selectionKeys 数量 = " + selectionKeys.size());

            //遍历 Set<SelectionKey>, 使用迭代器遍历
            Iterator<SelectionKey> keyIterator = selectionKeys.iterator();

            while (keyIterator.hasNext()) {
                //获取到SelectionKey
                SelectionKey key = keyIterator.next();
                //根据key 对应的通道发生的事件做相应处理
                if (key.isAcceptable()) { //如果是 OP_ACCEPT, 有新的客户端连接
                    //该该客户端生成一个 SocketChannel
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    log.info("客户端连接成功 生成了一个 socketChannel " + socketChannel.hashCode());
                    //将  SocketChannel 设置为非阻塞
                    socketChannel.configureBlocking(false);
                    //将socketChannel 注册到selector, 关注事件为 OP_READ， 同时给socketChannel
                    //关联一个Buffer
                    socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));

                    log.info("客户端连接后 ，注册的 selectionkey 数量=" + selector.keys().size()); //2,3,4..


                }
                if (key.isReadable()) {  //发生 OP_READ

                    //通过key 反向获取到对应channel
                    SocketChannel channel = (SocketChannel) key.channel();

                    //获取到该channel关联的buffer
                    ByteBuffer buffer = (ByteBuffer) key.attachment();
                    channel.read(buffer);
                    log.info("from 客户端 " + new String(buffer.array()));

                }

                //手动从集合中移动当前的selectionKey, 防止重复操作
                keyIterator.remove();
            }
        }
    }
}

客户端

@Slf4j
public class NIOClient {
    public static void main(String[] args) throws Exception {

        //得到一个网络通道
        SocketChannel socketChannel = SocketChannel.open();
        //设置非阻塞
        socketChannel.configureBlocking(false);
        //提供服务器端的ip 和 端口
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
        //连接服务器
        if (!socketChannel.connect(inetSocketAddress)) {
            while (!socketChannel.finishConnect()) {
                log.info("因为连接需要时间，客户端不会阻塞，可以做其它工作..");
            }
        }

        //...如果连接成功，就发送数据
        String str = "hello, 尚硅谷~";
        //Wraps a byte array into a buffer
        ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
        //发送数据，将 buffer 数据写入 channel
        socketChannel.write(buffer);
        System.in.read();

    }
}

SelectionKey

SelectionKey，表示 Selector 和网络通道的注册关系, 共四种:

int OP_ACCEPT：有新的网络连接可以 accept，值为 16
int OP_CONNECT：代表连接已经建立，值为 8
int OP_READ：代表读操作，值为 1 
int OP_WRITE：代表写操作，值为 4

源码中：

public static final int OP_READ = 1 << 0; 
public static final int OP_WRITE = 1 << 2;
public static final int OP_CONNECT = 1 << 3;
public static final int OP_ACCEPT = 1 << 4;

SelectionKey相关方法

public abstract class SelectionKey {
	public abstract Selector selector();//得到与之关联的 Selector 对象
	public abstract SelectableChannel channel();//得到与之关联的通道
	public final Object attachment();//得到与之关联的共享数据
	public abstract SelectionKey interestOps(int ops);//设置或改变监听事件
	public final boolean isAcceptable();//是否可以 accept
	public final boolean isReadable();//是否可以读
	public final boolean isWritable();//是否可以写
}

ServerSocketChannel

ServerSocketChannel 在服务器端监听新的客户端 Socket 连接

SocketChannel

SocketChannel，网络 IO 通道，具体负责进行读写操作。NIO 把缓冲区的数据写入通道，或者把通道里的数据读到缓冲区。

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

实例要求:

编写一个 NIO 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞）
实现多人群聊
服务器端：可以监测用户上线，离线，并实现消息转发功能
客户端：通过channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息(有服务器转发得到)
目的：进一步理解NIO非阻塞网络编程机制

服务器端

@Slf4j
public class MyGroupChatServer {

    private Selector selector;
    private ServerSocketChannel serverSocketChannel;

    /**
     * 构造器，进行初始化工作
     */
    public MyGroupChatServer() {
        try {
            selector = Selector.open();

            serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.socket().bind(new InetSocketAddress("127.0.0.1", 6677));
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 进行监听工作
     */
    private void listen() {
        try {
            while (true) {
                int select = selector.select(3000);

                if (select > 0) {
                    Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                    while (iterator.hasNext()) {
                        SelectionKey selectionKey = iterator.next();

                        if (selectionKey.isAcceptable()) {
                            SocketChannel socketChannel = serverSocketChannel.accept();
                            socketChannel.configureBlocking(false);

                            socketChannel.register(selector, SelectionKey.OP_READ);
                            log.info("{} 上线了", socketChannel.getRemoteAddress());
                        }

                        if (selectionKey.isReadable()) {
                            readData(selectionKey);
                        }

                        iterator.remove();
                    }
                } else {
                    log.info("未监听到事件");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 读取客户端信息
     *
     * @param selectionKey
     */
    private void readData(SelectionKey selectionKey) {
        SocketChannel channel = (SocketChannel) selectionKey.channel();

        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        try {
            int read = channel.read(byteBuffer);

            if (read > 0) {
                String msg = new String(byteBuffer.array());
                log.info("from 客户端：{}", msg);
                sendInfoToOtherClients(msg, channel);
            }
        } catch (IOException e) {
            e.printStackTrace();
            try {
                log.info("{} 离线了", channel.getRemoteAddress());

                // 取消注册
                selectionKey.cancel();

                // 关闭通道
                channel.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

    }

    /**
     * 转发消息给其它客户
     *
     * @param msg
     * @param channel
     */
    private void sendInfoToOtherClients(String msg, SocketChannel channel) {
        log.info("转发消息到其他客户端");
        for (SelectionKey selectionKey : selector.keys()) {
            SelectableChannel targetChannel = selectionKey.channel();
            if (targetChannel instanceof SocketChannel && targetChannel != channel) {
                SocketChannel destSocketChannel = (SocketChannel) targetChannel;
                try {
                    destSocketChannel.write(ByteBuffer.wrap(msg.getBytes()));
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        MyGroupChatServer myGroupChatServer = new MyGroupChatServer();
        log.info("服务器开启监听");
        myGroupChatServer.listen();
    }
}

客户端

@Slf4j
public class MyGroupChatClient {

    private Selector selector;
    private SocketChannel socketChannel;
    private String userName;

    public MyGroupChatClient() {
        try {
            selector = Selector.open();
            socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 6677));
            socketChannel.configureBlocking(false);
            socketChannel.register(selector, SelectionKey.OP_READ);
            userName = socketChannel.getLocalAddress().toString().substring(1);
            log.info("{} is ok", userName);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        MyGroupChatClient myGroupChatClient = new MyGroupChatClient();
        new Thread(() -> {
            while (true) {
                myGroupChatClient.readInfo();
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            myGroupChatClient.sendInfo(s);
        }
    }

    private void sendInfo(String s) {
        String msg = userName + " 说：" + s;
        try {
            socketChannel.write(ByteBuffer.wrap(msg.getBytes()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void readInfo() {
        try {
            int select = selector.select();
            if (select > 0) {
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    if (selectionKey.isReadable()) {
                        SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                        socketChannel.read(byteBuffer);
                        String msg = new String(byteBuffer.array());
                        log.info("接收到消息：{}", msg);
                    }

                    iterator.remove();
                }
            } else {
                log.info("没有可用通道");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

NIO与零拷贝

零拷贝基本介绍

零拷贝是网络编程的关键，很多性能优化都离不开。
在 Java 程序中，常用的零拷贝有 mmap(内存映射) 和 sendFile。
我们说零拷贝，是从操作系统的角度来说的，是指没有 CPU 拷贝。因为内核缓冲区之间，没有数据是重复的（只有 kernel buffer 有一份数据）。
零拷贝不仅仅带来更少的数据复制，还能带来其他的性能优势，例如更少的上下文切换，更少的 CPU 缓存伪共享以及无 CPU 校验和计算。

传统IO

DMA：direct memory access，直接内存拷贝(不使用CPU)

mmap 优化

mmap 通过内存映射，将文件映射到内核缓冲区，同时，用户空间可以共享内核空间的数据。这样，在进行网络传输时，就可以减少内核空间到用户空间的拷贝次数。如下图

sendFile 优化

Linux 2.1 版本提供了 sendFile 函数，其基本原理如下：数据根本不经过用户态，直接从内核缓冲区进入到 Socket Buffer，同时，由于和用户态完全无关，就减少了一次上下文切换。

Linux 在 2.4 版本中，做了一些修改，避免了从内核缓冲区拷贝到 Socket buffer 的操作，直接拷贝到协议栈，从而再一次减少了数据拷贝。具体如下图和小结：

这里其实有一次cpu 拷贝 kernel buffer -> socket buffer，但是，拷贝的信息很少，比如 lenght , offset , 消耗低，可以忽略

mmap 和 sendFile 的区别

mmap 适合小数据量读写，sendFile 适合大文件传输。

mmap 需要 4 次上下文切换，3 次数据拷贝；sendFile 需要 3 次上下文切换，最少 2 次数据拷贝。

sendFile 可以利用 DMA 方式，减少 CPU 拷贝，mmap 则不能（必须从内核拷贝到 Socket 缓冲区）。

NIO 零拷贝案例

案例要求：

使用传统的 IO 方法传递一个大文件
使用NIO 零拷贝方式传递(transferTo)一个大文件
看看两种传递方式耗时时间分别是多少

结论：

传统 IO：发送总字节数： 492929032, 耗时： 2762
零拷贝：发送的总的字节数 =492929032 耗时:451

注意：Windows 限制每次调用 transferTo 只能发送 8M

以下代码绕开 Windows 的 8M 限制：

public class NewIOClient {
    public static void main(String[] args) throws Exception {

        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress("localhost", 7001));
        String filename = "D:\\111.rmvb";

        //得到一个文件channel
        FileChannel fileChannel = new FileInputStream(filename).getChannel();

        //准备发送
        long startTime = System.currentTimeMillis();

        //在linux下一个transferTo 方法就可以完成传输
        //在windows 下 一次调用 transferTo 只能发送8m , 就需要分段传输文件, 而且要主要
        //传输时的位置 =》 课后思考...
        //transferTo 底层使用到零拷贝

        // 总共字节数
        long totalSize = fileChannel.size();

        // windows平台最大传送数据包
        long max_pkg = 8 * 1024 * 1024;

        // 本次传输到的位置
        long cur_pos = 0;

        long transSize = 0;

        // 如果剩余的字节数量 > 8M
        while (totalSize > max_pkg) {
            // 本次传输的字节数
            long tmp = fileChannel.transferTo(cur_pos, max_pkg, socketChannel);

            // 传输后剩余字节数
            totalSize -= tmp;

            // 传输到的位置
            cur_pos += tmp;

            // 已经传输的大小 用于校验
            transSize += tmp;
        }

        // 如果还有剩余,则将剩余一次性传输
        if (totalSize > 0) {
            long tmp = fileChannel.transferTo(cur_pos, totalSize, socketChannel);
            transSize += tmp;
        }
        
        System.out.println("发送的总的字节数 =" + transSize + " 耗时:" + (System.currentTimeMillis() - startTime));

        //关闭
        fileChannel.close();

    }
}

Java AIO 基本介绍

JDK 7 引入了 Asynchronous I/O，即 AIO。在进行 I/O 编程中，常用到两种模式：Reactor 和 Proactor。Java 的 NIO 就是 Reactor，当有事件触发时，服务器端得到通知，进行相应的处理
AIO 即 NIO2.0，叫做异步不阻塞的 IO。AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用
目前 AIO 还没有广泛应用，Netty 也是基于NIO, 而不是AIO

BIO、NIO、AIO对比表

	BIO	NIO	AIO
IO 模型	同步阻塞	同步非阻塞（多路复用）	异步非阻塞
编程难度	简单	复杂	复杂
可靠性	差	好	好
吞吐量	低	高	高

举例说明：

同步阻塞：到理发店理发，就一直等理发师，直到轮到自己理发。
同步非阻塞：到理发店理发，发现前面有其它人理发，给理发师说下，先干其他事情，一会过来看是否轮到自己.
异步非阻塞：给理发师打电话，让理发师上门服务，自己干其它事情，理发师自己来家给你理发

posted @ 2020-09-30 17:07 流星<。)#)))≦ 阅读(200) 评论(0) 编辑收藏举报

刷新页面返回顶部

20200930 3. Java NIO 编程

Java NIO 编程

基本介绍

NIO 和 BIO 的比较

NIO 三大核心

NIO 三大核心原理示意图

缓冲区(Buffer)

基本介绍

Buffer 的基本使用

Buffer 类及其子类

通道(Channel)

基本介绍

FileChannel 类

应用实例1-本地文件写数据

应用实例2-本地文件读数据

应用实例3-使用一个Buffer完成文件读取

应用实例4-拷贝文件 transferFrom 方法

关于 Buffer 和 Channel 的注意事项和细节

Selector(选择器)

基本介绍

特点再说明:

Selector类相关方法

注意事项

NIO 非阻塞 网络编程原理分析

NIO 非阻塞 网络编程快速入门

服务器端

客户端

SelectionKey

ServerSocketChannel

SocketChannel

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

服务器端

客户端

NIO与零拷贝

零拷贝基本介绍

传统IO

mmap 优化

mmap 和 sendFile 的区别

NIO 零拷贝案例

Java AIO 基本介绍

BIO、NIO、AIO对比表

公告

NIO 非阻塞网络编程原理分析

NIO 非阻塞网络编程快速入门