NIO笔记

NIO

NIO：非阻塞IO

Channel

相当于流，只不过是双向的,可以从channel中读取数据到buffer 也可以从buffer中读取数据到channel

常见的channel:

FileChannel:用来作为文件的数据传输通道
DatagramChannel:用来作为UDP时数据传输通道
SocketChannel:TCP时数据传输通道
ServerSocketChannel：TCP时数据传输通道，专用于服务器端

FileChannel

获取

不能直接打开 FileChannel，必须通过 FileInputStream、FileOutputStream 或者 RandomAccessFile 来获取 FileChannel，它们都有 getChannel 方法

通过 FileInputStream 获取的 channel 只能读
通过 FileOutputStream 获取的 channel 只能写
通过 RandomAccessFile 是否能读写根据构造 RandomAccessFile 时的读写模式决定

读取(往buffer里读)

通过 FileInputStream 获取channel，通过read方法将数据写入到ByteBuffer中

read方法的返回值表示读到了多少字节，若读到了文件末尾则返回-1

int readBytes = channel.read(buffer);

可根据返回值判断是否读取完毕

while(channel.read(buffer) > 0) {
    // 进行对应操作
    ...
}

写入（写入到channel中）

因为channel也是有大小的，所以** write 方法并不能保证一次将 buffer 中的内容全部写入 channel **。必须需要按照以下规则进行写入

// 通过hasRemaining()方法查看缓冲区中是否还有数据未写入到通道中
while(buffer.hasRemaining()) {
channel.write(buffer);
}

关闭

可以通过调用流的close()方法间接关闭channel，但是一般情况通过try-with-resource进行关闭

位置

channel也拥有一个保存读取数据位置的属性，即position


long pos = channel.position();

可以通过position(int pos)设置channel中position的值


long newPos = ...;
channel.position(newPos);

设置当前位置时，如果设置为文件的末尾

这时读取会返回 -1
这时写入，会追加内容，但要注意如果 position 超过了文件末尾，再写入时在新内容和原末尾之间会有空洞（00）

强制写入

操作系统出于性能的考虑，会将数据缓存，不是立刻写入磁盘，而是等到缓存满了以后将所有数据一次性的写入磁盘。可以调用 force(true) 方法将文件内容和元数据（文件的权限等信息）立刻写入磁盘

两个channel之间传输数据

使用transferTo方法可以快速、高效地将一个channel中的数据传输到另一个channel中，但一次只能传输2G的内容

transferTo底层使用了零拷贝技术

public class TestChannel {
    public static void main(String[] args){
        try (FileInputStream fis = new FileInputStream("stu.txt");
             FileOutputStream fos = new FileOutputStream("student.txt");
             FileChannel inputChannel = fis.getChannel();
             FileChannel outputChannel = fos.getChannel()) {
            // 参数：inputChannel的起始位置，传输数据的大小，目的channel
            // 返回值为传输的数据的字节数
            // transferTo一次只能传输2G的数据
            inputChannel.transferTo(0, inputChannel.size(), outputChannel);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

当传输的文件大于2G时，需要使用以下方法进行多次传输

public class TestChannel {
    public static void main(String[] args){
        try (FileInputStream fis = new FileInputStream("stu.txt");
             FileOutputStream fos = new FileOutputStream("student.txt");
             FileChannel inputChannel = fis.getChannel();
             FileChannel outputChannel = fos.getChannel()) {
            
            long size = inputChannel.size();
            //剩余容量，初始值为需要传输文件的大小
            long left = size;
            // 分多次传输
            while (left > 0) {
                // transferTo返回值为传输了的字节数
                //注意每次从已经传输的字节数处开始传
                left -= inputChannel.transferTo(size-left, left, outputChannel);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Buffer

作为数据的缓冲区

常见的buffer:

ByteBuffer: 以字节为单位缓冲数据
- MappedByteBuffer:
- DirectByteBuffer:
- HeapByteBuffer:
ShortBuffer:
IntBuffer:
FloatBuffer:
CharBuffer

使用步骤

1.向 buffer 写入数据，例如调用 channel.read(buffer)
2.调用 flip() 切换至读模式 (读取buffer中的数据)
3.从 buffer 读取数据，例如调用 buffer.get()
4.调用 clear() 或者compact()切换至写模式
重复以上步骤

示例：

public class TestByteBuffer {
    public static void main(String[] args) {
        // 获得FileChannel
        try (FileChannel channel = new FileInputStream("stu.txt").getChannel()) {
            // 获得缓冲区,大小为10字节
            ByteBuffer buffer = ByteBuffer.allocate(10);
            int hasNext = 0;
            StringBuilder builder = new StringBuilder();
            while((hasNext = channel.read(buffer)) > 0) {
                // 切换模式 limit=position, position=0
                buffer.flip();
                // 当buffer中还有数据时，获取其中的数据
                while(buffer.hasRemaining()) {
                    builder.append((char)buffer.get());
                }
                // 切换模式 position=0, limit=capacity
                buffer.clear();
            }
            System.out.println(builder.toString());
        } catch (IOException e) {
        }
    }
}

内部结构

字节缓冲区的父类Buffer中有几个核心属性，如下

// Invariants: mark <= position <= limit <= capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;

capacity：缓冲区的容量。通过构造函数赋予，一旦设置，无法更改
limit：缓冲区的界限。位于limit 后的数据不可读写。缓冲区的限制不能为负，并且不能大于其容量
position：下一个读写位置的索引。缓冲区的position不能为负，并且不能大于limit
mark：记录当前position的值。position被改变后，可以通过调用reset() 方法恢复到mark的位置。

核心方法

put()

put()方法可以将一个数据放入到缓冲区中。
进行该操作后，postition的值会+1，指向下一个可以放入的位置。capacity = limit ，为缓冲区容量的值。

flip()

flip()方法会切换对缓冲区的操作模式，由写->读 / 读->写
进行该操作后:

如果是写模式->读模式，position = 0 ， limit 指向最后一个元素的下一个位置，capacity不变
如果是读->写，则恢复为put()方法中的值

get()

get()方法会读取缓冲区中的一个值
进行该操作后，position会+1，如果超过了limit则会抛出异常
注意：get(i)方法不会改变position的值

rewind()

该方法只能在读模式下使用
rewind()方法后，会恢复position、limit和capacity的值，变为进行get()前的值

clear()方法

clear()方法会将缓冲区中的各个属性恢复为最初的状态，position = 0, capacity = limit
此时缓冲区的数据依然存在，处于“被遗忘”状态，下次进行写操作时会覆盖这些数据

mark()和reset()方法

mark()方法会将postion的值保存到mark属性中
reset()方法会将position的值改为mark中保存的值

compact()方法

此方法为ByteBuffer的方法，而不是Buffer的方法
compact会把未读完的数据向前压缩，然后切换到写模式
数据前移后，原位置的值并未清零，写时会覆盖之前的值

clear() VS compact():

clear只是对position、limit、mark进行重置，而compact在对position进行设置，以及limit、mark进行重置的同时，还涉及到数据在内存中拷贝（会调用arraycopy）。所以compact比clear更耗性能。但compact能保存你未读取的数据，将新数据追加到为读取的数据之后；而clear则不行，若你调用了clear，则未读取的数据就无法再读取到了

字符串与ByteBuffer的相互转换

方法一:

编码：字符串调用getByte方法获得byte数组，将byte数组放入ByteBuffer中

解码：先调用ByteBuffer的flip方法，然后通过StandardCharsets的decoder方法解码

public class Translate {
    public static void main(String[] args) {
        // 准备两个字符串
        String str1 = "hello";
        String str2 = "";


        ByteBuffer buffer1 = ByteBuffer.allocate(16);
        // 通过字符串的getByte方法获得字节数组，放入缓冲区中
        buffer1.put(str1.getBytes());
        

        // 将缓冲区中的数据转化为字符串
        // 切换模式
        buffer1.flip();
        
        // 通过StandardCharsets解码，获得CharBuffer，再通过toString获得字符串
        //**注意这个方法会使buffer的position发生移动！**
        str2 = StandardCharsets.UTF_8.decode(buffer1).toString();
        System.out.println(str2);
        }
}

粘包与半包

现象

网络上有多条数据发送给服务端，数据之间使用 \n 进行分隔
但由于某种原因这些数据在接收时，被进行了重新组合，例如原始数据有3条为

Hello,world\n
I’m Nyima\n
How are you?\n

变成了下面的两个 byteBuffer (粘包，半包)

Hello,world\nI’m Nyima\nHo
w are you?\n

出现原因

粘包:发送方在发送数据时，并不是一条一条地发送数据，而是将数据整合在一起，当数据达到一定的数量后再一起发送。这就会导致多条信息被放在一个缓冲区中被一起发送出去

半包:接收方的缓冲区的大小是有限的，当接收方的缓冲区满了以后，就需要将信息截断，等缓冲区空了以后再继续放入数据。这就会发生一段完整的数据最后被截断的现象

解决办法

1.通过get(index)方法遍历ByteBuffer，遇到分隔符时进行处理。注意：get(index)不会改变position的值
记录该段数据长度，以便于申请对应大小的缓冲区
将缓冲区的数据通过get()方法写入到target中
2.调用compact方法切换模式，因为缓冲区中可能还有未读的数据

public class ByteBufferDemo {
    public static void main(String[] args) {

        ByteBuffer buffer = ByteBuffer.allocate(32);
        // 模拟粘包+半包
        buffer.put("Hello,world\nI'm Nyima\nHo".getBytes());
        // 调用split函数处理
        split(buffer);
        buffer.put("w are you?\n".getBytes());
        split(buffer);
    }

    private static void split(ByteBuffer buffer) {
        // 切换为读模式
        buffer.flip();

        //遍历读取buffer中每个字节
        for(int i = 0; i < buffer.limit(); i++) {

            // 遍历寻找分隔符
            // **get(i)不会移动position**  
            if (buffer.get(i) == '\n') {
                // 缓冲区长度
                int length = i+1-buffer.position();
                ByteBuffer target = ByteBuffer.allocate(length);
                // 将前面的内容写入target缓冲区
                for(int j = 0; j < length; j++) {
                    // 将buffer中的数据写入target中
                    target.put(buffer.get());
                }
            }
        }
        // 切换为写模式，但是缓冲区可能未读完，这里需要使用compact
        buffer.compact();
    }
}

Selector

对于Selector 我们需要结合服务器的设计与演化来理解

多线程版

为每个连接分别开辟一个线程，分别去处理对应的socke连接

这种方法存在以下几个问题

1.内存占用高：每个线程都需要占用一定的内存，当连接较多时，会开辟大量线程，导致占用大量内存
2.线程上下文切换成本高
因此只适合连接数少的场景，连接数过多，会导致创建很多线程，从而出现问题

线程池版
使用线程池，让线程池中的线程去处理连接

这种方法存在以下几个问题
1.阻塞模式下，线程仅能处理一个连接：线程池中的线程获取任务（task）后，只有当其执行完任务之后（断开连接后），才会去获取并执行下一个任务
若socke连接一直未断开，则其对应的线程无法处理其他socket连接
2.仅适合短连接场景:短连接即建立连接发送请求并响应后就立即断开，使得线程池中的线程可以快速处理其他连接

使用Selector
selector 的作用就是配合一个线程来管理多个 channel，获取这些 channel 上发生的事件，这些 channel 工作在非阻塞模式下，当一个channel中没有执行任务时，线程可以去执行其他channel中的任务。适合连接数多，但流量较少的场景

若事件未就绪，调用 selector 的 select() 方法会阻塞线程，直到 channel 发生了就绪事件。这些事件就绪后，select 方法就会返回这些事件交给 thread 来处理

网络编程

阻塞

阻塞模式下，相关方法都会导致线程暂停
ServerSocketChannel.accept 会在没有连接建立时让线程暂停
SocketChannel.read 会在通道中没有数据可读时让线程暂停

阻塞的表现其实就是线程暂停了，暂停期间不会占用 cpu，但线程相当于闲置。单线程下，阻塞方法之间相互影响，几乎不能正常工作，需要多线程支持。但多线程下，有新的问题，体现在以下方面：32 位 jvm 一个线程 320k，64 位 jvm 一个线程 1024k，如果连接数过多，必然导致 OOM，并且线程太多，反而会因为频繁上下文切换导致性能降低。可以采用线程池技术来减少线程数和线程上下文切换，但治标不治本，如果有很多连接建立，但长时间 inactive，会阻塞线程池中所有线程，因此不适合长连接，只适合短连接

我们看一下单线程下的阻塞例子：

服务端代码：


public class Server {
    public static void main(String[] args) {
        // 创建缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(16);
        // 获得服务器通道
        try(ServerSocketChannel server = ServerSocketChannel.open()) {
            // 为服务器通道绑定端口
            server.bind(new InetSocketAddress(8080));
            // 用户存放连接的集合
            ArrayList<SocketChannel> channels = new ArrayList<>();
            // 循环接收连接
            while (true) {
                System.out.println("before connecting...");
                // 返回值为SocketChannel，没有连接时，会阻塞线程
                SocketChannel socketChannel = server.accept();
                System.out.println("after connecting...");
                channels.add(socketChannel);
                // 循环遍历集合中的连接
                for(SocketChannel channel : channels) {
                    System.out.println("before reading");
                    // 处理通道中的数据
                    // 当通道中没有数据可读时，会阻塞线程
                    channel.read(buffer);
                    buffer.flip();
                    //这是一个自己定义的工具类 用来打印buffer中信息
                    ByteBufferUtil.debugRead(buffer);
                    buffer.clear();
                    System.out.println("after reading");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端代码

public class Client {
    public static void main(String[] args) {
        try (SocketChannel socketChannel = SocketChannel.open()) {
            // 建立连接
            socketChannel.connect(new InetSocketAddress("localhost", 8080));
            System.out.println("waiting...");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行结果

客户端-服务器建立连接前：服务器端因accept阻塞（accept方法处阻塞）
客户端-服务器建立连接后，客户端发送消息前：服务器端因通道为空被阻塞（read方法处阻塞）
客户端发送数据后，服务器处理通道中的数据。再次进入循环时，再次被accept阻塞
之前的客户端再次发送消息，服务器端因为被accept阻塞，无法处理之前客户端发送到通道中的信息

非阻塞

可以通过ServerSocketChannel的configureBlocking(false)方法将获得连接设置为非阻塞的。此时若没有连接，accept会返回null

可以通过SocketChannel的configureBlocking(false)方法将从通道中读取数据设置为非阻塞的。若此时通道中没有数据可读，read会返回-1

服务器端代码如下：

public class Server {
    public static void main(String[] args) {
        // 创建缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(16);
        // 获得服务器通道
        try(ServerSocketChannel server = ServerSocketChannel.open()) {
            // 为服务器通道绑定端口
            server.bind(new InetSocketAddress(8080));
            // 用户存放连接的集合
            ArrayList<SocketChannel> channels = new ArrayList<>();
            // 循环接收连接
            while (true) {
                // 设置为非阻塞模式，没有连接时返回null，不会阻塞线程
                server.configureBlocking(false);
                SocketChannel socketChannel = server.accept();
                // 通道不为空时才将连接放入到集合中
                if (socketChannel != null) {
                    System.out.println("after connecting...");
                    channels.add(socketChannel);
                }
                // 循环遍历集合中的连接
                for(SocketChannel channel : channels) {
                    // 处理通道中的数据
                    // 设置为非阻塞模式，若通道中没有数据，会返回0，不会阻塞线程
                    channel.configureBlocking(false);
                    int read = channel.read(buffer);
                    if(read > 0) {
                        buffer.flip();
                        ByteBufferUtil.debugRead(buffer);
                        buffer.clear();
                        System.out.println("after reading");
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这样写存在一个问题，因为设置为了非阻塞，会一直执行while(true)中的代码，CPU一直处于忙碌状态，会使得性能变低，所以实际情况中不使用这种方法处理请求。

我们希望的是当有链接或者有数据需要读取时 CPU再去处理

Selector

多路复用

单线程可以配合 Selector 完成对多个 Channel 可读写事件的监控，这称之为多路复用

多路复用仅针对网络 IO，普通文件 IO 无法利用多路复用
如果不用 Selector 的非阻塞模式，线程大部分时间都在做无用功，而 Selector 能够保证

有可连接事件时才去连接
有可读事件才去读取
有可写事件才去写入
- 限于网络传输能力，Channel 未必时时可写，一旦 Channel 可写，会触发 Selector 的可写事件

步骤

1.创建selector管理多个channel

Selector selector = Selector.open();

2.把channel注册进selector中
第一个参数为selector对象，第二个参数为关注的事件，第三个参数为附件（在消息边界的部分会讲）
返回值为SelectionKey，将来事件发生后通过它可以知道事件和事件对应的channel

SelectionKey  sscKey=ssc.register(selector,0,null)

3.指定SelectionKey 关注的事件

sscKey.interestOps(SelectionKey.OP_ACCEPT);

如果需要关注多个事件，用+号

sscKey.interestOps(SelectionKey.OP_ACCEPT+SelectionKey.OP_WRITE);

事件有：

accept:有链接请求时触发
connect:客户端在链接建立后触发
read: 有数据可以读取时触发
write: 有数据可写时触发

4.调用selector的select方法

没有事件发生就阻塞有事件发生再运行

在有事件没有处理时不会阻塞

selector.select();

也可以设置超时时间

selector.select(long timeout);

5.处理事件

//获得selctor对应的事件集合
Set<SelectionKey> selectionKeys = selector.selectedKeys();
//使用迭代器遍历（因为待会需要在遍历时删除，所以只能使用迭代器）
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                // 判断key的类型
                if(key.isAcceptable()) {
                    // 获得key对应的channel
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                    System.out.println("before accepting...");
                    
    		    // 获取连接并处理，而且是必须处理，否则需要取消 key.cancel()
                    SocketChannel socketChannel = channel.accept();
                    System.out.println("after accepting...");
                    
                    // 处理完毕后移除
                    iterator.remove();
                    }
                }

事件发生后能否不处理?
事件发生后，要么处理，要么取消（cancel），不能什么都不做，否则下次该事件仍会触发，这是因为 nio 底层使用的是水平触发

为什么必须要从集合中删除事件？
当选择器中的通道对应的事件发生后，selecionKey会被放到另一个集合中，但是selecionKey不会自动移除，所以需要我们在处理完一个事件后，通过迭代器手动移除其中的selecionKey。否则会导致已被处理过的事件再次被处理，就会引发错误

总代码：

public class SelectServer {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(16);
        // 获得服务器通道
        try(ServerSocketChannel server = ServerSocketChannel.open()) {
            server.bind(new InetSocketAddress(8080));
            // 创建选择器
            Selector selector = Selector.open();
            
            // 通道必须设置为非阻塞模式
            server.configureBlocking(false);
            // 将通道注册到选择器中，并设置感兴趣的事件
            server.register(selector, SelectionKey.OP_ACCEPT);
            while (true) {
                // 若没有事件就绪，线程会被阻塞，反之不会被阻塞。从而避免了CPU空转
                // 返回值为就绪的事件个数
                int ready = selector.select();
                System.out.println("selector ready counts : " + ready);
                
                // 获取所有事件
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                
                // 使用迭代器遍历事件
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    
                    // 判断key的类型
                    if(key.isAcceptable()) {
                        // 获得key对应的channel
                        ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                        System.out.println("before accepting...");
                        
        		// 获取连接并处理，而且是必须处理，否则需要取消
                        SocketChannel socketChannel = channel.accept();
                        System.out.println("after accepting...");
                        
                        // 处理完毕后移除
                        iterator.remove();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

断开处理

当客户端与服务器之间的连接断开时，会给服务器端发送一个读事件，对异常断开和正常断开需要加以不同的方式进行处理

正常断开(close()方法)
正常断开时，服务器端的channel.read(buffer)方法的返回值为-1，所以当结束到返回值为-1时，需要调用key的cancel方法取消此事件，并在取消后移除该事件

        // 使用迭代器遍历事件
        Iterator<SelectionKey> iterator = selectionKeys.iterator();
        while (iterator.hasNext()) {
            SelectionKey key = iterator.next();
            
            // 判断key的类型
            if(key.isReadable()) {
              try{

                // 获得key对应的channel
                SocketChannel channel = (SocketChannel) key.channel();
                ByteBuffer buf=ByteBuffer.allocate(16);
               int read=channel.read(buf);
                //正常断开
                if(read==-1){
                   key.cancel()
                }else{
                 //切换至读模式
                 buf.flip();
                 System.out.println(CharSet.forName("utf-8").decode(buf).toString());
                 buf.clear();
                  }

                 }
                 //异常断开
                  catch(IOException e){
                      key.cancel();
                    }
               // 处理完毕后移除
               iterator.remove();
            }
        }

异常断开
异常断开时，会抛出IOException异常，在try-catch的catch块中捕获异常并调用key的cancel方法即可

消息边界

不处理消息边界存在的问题
将缓冲区的大小设置为4个字节，发送2个汉字（你好）(UTF-8下是6个字节)，通过decode解码并打印时，会出现乱码

ByteBuffer buffer = ByteBuffer.allocate(4);
// 解码并打印
System.out.println(StandardCharsets.UTF_8.decode(buffer));

你�
��

这是因为UTF-8字符集下，1个汉字占用3个字节，此时缓冲区大小为4个字节，一次读时间无法处理完通道中的所有数据，所以一共会触发两次读事件。这就导致你好的好字被拆分为了前半部分和后半部分发送，解码时就会出现问题

处理消息边界
传输的文本可能有以下三种情况：
- 文本大于缓冲区大小。此时需要将缓冲区进行扩容
- 发生半包现象
- 发生粘包现象

解决思路大致有以下三种：

固定消息长度，数据包大小一样，服务器按预定长度读取，当发送的数据较少时，需要将数据进行填充，直到长度与消息规定长度一致。缺点是浪费带宽
另一种思路是按分隔符拆分，缺点是效率低，需要一个一个字符地去匹配分隔符
TLV 格式，即 Type 类型、Length 长度、Value 数据（也就是在消息开头用一些空间存放后面数据的长度），如HTTP请求头中的Content-Type与Content-Length。类型和长度
已知的情况下，就可以方便获取消息大小，分配合适的 buffer，缺点是 buffer 需要提前分配，如果内容过大，则影响 server 吞吐量

附件与扩容
当我们发送的数据大小大于接受的ByteBuffer的容量时会触发多次read事件直到将发送的数据读取完

根据之前的分析，由于我们需要对ByteBuffer进行扩容，因此我们必须保证这多次read使用的是同一个ByteBuffer,我们将ByteBuffer与SocketChannel进行绑定，每个SocketChannel拥有一个ByteBuffer，这就是附件

Channel的register方法还有第三个参数：附件，可以向其中放入一个Object类型的对象，该对象会与登记的Channel以及其对应的SelectionKey绑定，可以从SelectionKey获取到对应通道的附件

public final SelectionKey register(Selector sel, int ops, Object att)

可通过SelectionKey的attachment()方法获得附件

ByteBuffer buffer = (ByteBuffer) key.attachment();

我们需要在READ事件发生后，将通道注册到Selector中时，对每个通道添加一个ByteBuffer附件，让每个通道发生读事件时都使用自己的通道，避免与其他通道发生冲突而导致问题

// 设置为非阻塞模式，同时将连接的通道也注册到选择其中，同时设置附件
socketChannel.configureBlocking(false);
ByteBuffer buffer = ByteBuffer.allocate(16);
// 添加通道对应的Buffer附件
socketChannel.register(selector, SelectionKey.OP_READ, buffer);

当Channel中的数据大于缓冲区时，需要对缓冲区进行扩容操作。此代码中的扩容的判定方法：Channel调用compact方法后，的position与limit相等，说明缓冲区中的数据并未被读取（容量太小），此时创建新的缓冲区，其大小扩大为两倍。同时还要将旧缓冲区中的数据拷贝到新的缓冲区中，同时调用SelectionKey的attach方法将新的缓冲区作为新的附件放入SelectionKey中


// 如果缓冲区太小，就进行扩容
if (buffer.position() == buffer.limit()) {
    ByteBuffer newBuffer = ByteBuffer.allocate(buffer.capacity()*2);
    // 将旧buffer中的内容放入新的buffer中
    newBuffer.put(buffer);
    // 将新buffer作为附件放到key中
    key.attach(newBuffer);
}

改造后的服务器代码如下

public class SelectServer {
    public static void main(String[] args) {
        // 获得服务器通道
        try(ServerSocketChannel server = ServerSocketChannel.open()) {
            server.bind(new InetSocketAddress(8080));
            // 创建选择器
            Selector selector = Selector.open();
            // 通道必须设置为非阻塞模式
            server.configureBlocking(false);
            // 将通道注册到选择器中，并设置感兴趣的事件
            server.register(selector, SelectionKey.OP_ACCEPT);
            // 为serverKey设置感兴趣的事件
            while (true) {
                // 若没有事件就绪，线程会被阻塞，反之不会被阻塞。从而避免了CPU空转
                // 返回值为就绪的事件个数
                int ready = selector.select();
                System.out.println("selector ready counts : " + ready);
                // 获取所有事件
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                // 使用迭代器遍历事件
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    // 判断key的类型
                    if(key.isAcceptable()) {
                        // 获得key对应的channel
                        ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                        System.out.println("before accepting...");
                        // 获取连接
                        SocketChannel socketChannel = channel.accept();
                        System.out.println("after accepting...");
                        // 设置为非阻塞模式，同时将连接的通道也注册到选择其中，同时设置附件
                        socketChannel.configureBlocking(false);
                        ByteBuffer buffer = ByteBuffer.allocate(16);
                        socketChannel.register(selector, SelectionKey.OP_READ, buffer);
                        // 处理完毕后移除
                        iterator.remove();
                    } else if (key.isReadable()) {
                        SocketChannel channel = (SocketChannel) key.channel();
                        System.out.println("before reading...");
                        // 通过key获得附件（buffer）
                        ByteBuffer buffer = (ByteBuffer) key.attachment();
                        int read = channel.read(buffer);
                        if(read == -1) {
                            key.cancel();
                            channel.close();
                        } else {
                            // 通过分隔符来分隔buffer中的数据
                            split(buffer);
                            // 如果缓冲区太小，就进行扩容
                            if (buffer.position() == buffer.limit()) {
                                ByteBuffer newBuffer = ByteBuffer.allocate(buffer.capacity()*2);
                                // 将旧buffer中的内容放入新的buffer中
                                buffer.flip();
                                newBuffer.put(buffer);
                                // 将新buffer放到key中作为附件
                                key.attach(newBuffer);
                            }
                        }
                        System.out.println("after reading...");
                        // 处理完毕后移除
                        iterator.remove();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void split(ByteBuffer buffer) {
        buffer.flip();
        for(int i = 0; i < buffer.limit(); i++) {
            // 遍历寻找分隔符
            // get(i)不会移动position
            if (buffer.get(i) == '\n') {
                // 缓冲区长度
                int length = i+1-buffer.position();
                ByteBuffer target = ByteBuffer.allocate(length);
                // 将前面的内容写入target缓冲区
                for(int j = 0; j < length; j++) {
                    // 将buffer中的数据写入target中
                    target.put(buffer.get());
                }
                // 打印结果
                ByteBufferUtil.debugAll(target);
            }
        }
        // 切换为写模式，但是缓冲区可能未读完，这里需要使用compact
        buffer.compact();
    }
}

ByteBuffer的大小分配

每个 channel 都需要记录可能被切分的消息，因为 ByteBuffer 不能被多个 channel 共同使用，因此需要为每个 channel 维护一个独立的 ByteBuffer
ByteBuffer 不能太大，比如一个 ByteBuffer 1Mb 的话，要支持百万连接就要 1Tb 内存，因此需要设计大小可变的 ByteBuffer
分配思路可以参考
- 一种思路是首先分配一个较小的 buffer，例如 4k，如果发现数据不够，再分配 8k 的 buffer，将 4k buffer 内容拷贝至 8k buffer，优点是消息连续容易处理，缺点是数据
  拷贝耗费性能
  参考实现 http://tutorials.jenkov.com/java-performance/resizable-array.html
- 另一种思路是用多个数组组成 buffer，一个数组不够，把多出来的内容写入新的数组，与前面的区别是消息存储不连续解析复杂，优点是避免了拷贝引起的性能损耗

write事件

服务器通过Buffer向通道中写入数据时，可能因为通道容量小于Buffer中的数据大小，导致无法一次性将Buffer中的数据全部写入到Channel中，这时便需要分多次写入，具体步骤如下

执行一次写操作，向将buffer中的内容写入到SocketChannel中，然后判断Buffer中是否还有数据
若Buffer中还有数据，则需要将SockerChannel注册到Seletor中，并关注写事件，同时将未写完的Buffer作为附件一起放入到SelectionKey中

//返回值为实际写入的字节数
int write = socket.write(buffer);
// 通道中可能无法放入缓冲区中的所有数据
if (buffer.hasRemaining()) {
   //关注可写事件
   selectionKey.interestOps(selectionKey.interestOps()+SelectionKey.OP_WRITE);
   //把没写完的数据挂在selectionKey上
   selectionKey.attach(buffer);
}

//等到可写事件到来
if(selectionKey.isWritable()){
    SocketChannel socket = (SocketChannel) selectionKey.channel();
    // 获得buffer
    ByteBuffer buffer = (ByteBuffer) selectionKey.attachment();
    // 执行写操作
    int write = socket.write(buffer);
    System.out.println(write);
    // 如果已经完成了写操作，需要移除selectionKey中的附件，同时不再对写事件感兴趣
    if (!buffer.hasRemaining()) {
        selectionKey.attach(null);
           
        selectionKey.interestOps(selectionKey.interestOps()-SelectionKey.OP_WRITE);
    }

}

多线程优化

充分利用多核CPU，分两组选择器：

Boss，专门处理 accept 事件（一个线程）
Worker，负责处理read事件和write事件（多个线程）
需要注意的是，每个selector绑定一个线程，线程的数目不能太多

实现思路

创建一个负责处理Accept事件的Boss线程，与多个负责处理Read事件的Worker线程

Boss线程执行的操作：

接受并处理Accepet事件，当Accept事件发生后，调用Worker的register(SocketChannel socket)方法，让Worker去处理Read事件，其中需要根据标识robin去判断将任务分配
给哪个Worker

// 创建固定数量的Worker
Worker[] workers = new Worker[4];
// 用于负载均衡的原子整数
AtomicInteger robin = new AtomicInteger(0);
// 负载均衡，轮询分配Worker
workers[robin.getAndIncrement()% workers.length].register(socket);

register(SocketChannel socket)方法会通过同步队列完成Boss线程与Worker线程之间的通信，让SocketChannel的注册任务被Worker线程执行。添加任务后需要调用
selector.wakeup()来唤醒被阻塞的Selector (select()方法处被阻塞)

public void register(final SocketChannel socket) throws IOException {
// 只启动一次
if (!started) {
   // 初始化操作
}
// 向同步队列中添加SocketChannel的注册事件
// 在Worker线程中执行注册事件
queue.add(new Runnable() {
    @Override
    public void run() {
        try {
            socket.register(selector, SelectionKey.OP_READ);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
});
// 唤醒被阻塞的Selector
// select类似LockSupport中的park，wakeup的原理类似LockSupport中的unpark
selector.wakeup();
}

Worker线程执行的操作
- 从同步队列中获取注册任务，并处理Read事件

实现代码

public class ThreadsServer {
    public static void main(String[] args) {
        try (ServerSocketChannel server = ServerSocketChannel.open()) {
            // 当前线程为Boss线程
            Thread.currentThread().setName("Boss");
            server.bind(new InetSocketAddress(8080));
            // 负责轮询Accept事件的Selector
            Selector boss = Selector.open();
            server.configureBlocking(false);
            server.register(boss, SelectionKey.OP_ACCEPT);
            // 创建固定数量的Worker
            Worker[] workers = new Worker[4];
            // 用于负载均衡的原子整数
            AtomicInteger robin = new AtomicInteger(0);
            for(int i = 0; i < workers.length; i++) {
                workers[i] = new Worker("worker-"+i);
            }
            while (true) {
                boss.select();
                Set<SelectionKey> selectionKeys = boss.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    iterator.remove();
                    // BossSelector负责Accept事件
                    if (key.isAcceptable()) {
                        // 建立连接
                        SocketChannel socket = server.accept();
                        System.out.println("connected...");
                        socket.configureBlocking(false);
                        // socket注册到Worker的Selector中
                        System.out.println("before read...");
                        // 负载均衡，轮询分配Worker
                        workers[robin.getAndIncrement()% workers.length].register(socket);
                        System.out.println("after read...");
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static class Worker implements Runnable {
        private Thread thread;
        private volatile Selector selector;
        private String name;
        private volatile boolean started = false;
        /**
         * 同步队列，用于Boss线程与Worker线程之间的通信
         */
        private ConcurrentLinkedQueue<Runnable> queue;

        public Worker(String name) {
            this.name = name;
        }

        public void register(final SocketChannel socket) throws IOException {
            // 只启动一次
            if (!started) {
                thread = new Thread(this, name);
                selector = Selector.open();
                queue = new ConcurrentLinkedQueue<>();
                
                thread.start();
                started = true;
            }
            
            // 向同步队列中添加SocketChannel的注册事件，只添加不执行
            queue.add(new Runnable() {
                @Override
                public void run() {
                    try {
                        socket.register(selector, SelectionKey.OP_READ);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
            // 唤醒被阻塞的Selector
            // 使得worker线程从selector.select()继续往下执行，获取到了同步队列中的socket.register()方法并执行
            selector.wakeup();
        }

        @Override
        public void run() {
            while (true) {
                try {
                    selector.select();
                    // 通过同步队列获得任务并运行
                    Runnable task = queue.poll();
                    if (task != null) {
                        // 获得任务，执行注册操作
                        task.run();
                    }
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();
                    Iterator<SelectionKey> iterator = selectionKeys.iterator();
                    while(iterator.hasNext()) {
                        SelectionKey key = iterator.next();
                        iterator.remove();
                        // Worker只负责Read事件
                        if (key.isReadable()) {
                            // 简化处理，省略细节
                            SocketChannel socket = (SocketChannel) key.channel();
                            ByteBuffer buffer = ByteBuffer.allocate(16);
                            socket.read(buffer);
                            buffer.flip();
                            ByteBufferUtil.debugAll(buffer);
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

概念剖析

Stream与Channel

stream 不会自动缓冲数据，channel 会利用系统提供的发送缓冲区、接收缓冲区（更为底层）
stream 仅支持阻塞 API，channel 同时支持阻塞、非阻塞 API，网络 channel 可配合 selector 实现多路复用
二者均为全双工，即读写可以同时进行
- 虽然Stream是单向流动的，但是它也是全双工的

IO模式

同步：线程自己去获取结果（一个线程）
例如：线程调用一个方法后，需要等待方法返回结果
异步：线程自己不去获取结果，而是由其它线程返回结果（至少两个线程）
例如：线程A调用一个方法后，继续向下运行，运行结果由线程B返回

当调用一次 channel.read 或 stream.read 后，会由用户态切换至操作系统内核态来完成真正数据读取，而读取又分为两个阶段，分别为：

等待数据阶段
复制数据阶段

IO模型主要有以下几种：

阻塞IO

用户线程进行read操作时，需要等待操作系统执行实际的read操作，此期间用户线程是被阻塞的，无法执行其他操作

非阻塞IO

在非阻塞模式下，以read为例，及时没有数据可读，仍然会返回结果（-1），而不是等待。但需要注意的是，当有数据可读的时候，在复制数据的过程中仍然是阻塞状态。

多路复用

在非阻塞模式下CPU一直处于一种忙碌状态（类似于不断询问谁有数据可读），CPU利用率不高，因此引出多路复用。

Java中通过Selector实现多路复用

当没有事件时，调用select方法会被阻塞住
一旦有一个或多个事件发生后，就会处理对应的事件，从而实现多路复用

多路复用与阻塞IO的区别

阻塞IO模式下，若线程因accept事件被阻塞，发生read事件后，仍需等待accept事件执行完成后，才能去处理read事件
多路复用模式下，一个事件发生后，若另一个事件处于阻塞状态，不会影响该事件的执行

异步非阻塞IO（AIO）

同步IO与异步IO的最主要区别在于：结果是否由其它线程送来！

线程1调用方法后理解返回，不会被阻塞也不需要立即获取结果
当方法的运行结果出来以后，由线程2将结果返回给线程1

异步模型需要底层操作系统（Kernel）提供支持

Windows 系统通过 IOCP 实现了真正的异步 IO
Linux 系统异步 IO 在 2.6 版本引入，但其底层实现还是用多路复用模拟了异步 IO，性能没有优势

零拷贝

零拷贝指的是数据无需拷贝到 JVM 内存中，同时具有以下三个优点

更少的用户态与内核态的切换
不利用 cpu 计算，减少 cpu 缓存伪共享
零拷贝适合小文件传输

传统IO问题

传统的 IO 将一个文件通过 socket 写出

File f = new File("helloword/data.txt");
RandomAccessFile file = new RandomAccessFile(file, "r");

byte[] buf = new byte[(int)f.length()];
file.read(buf);

Socket socket = ...;
socket.getOutputStream().write(buf);

内部工作流如下

1.Java 本身并不具备 IO 读写能力，因此 read 方法调用后，要从 Java 程序的用户态切换至内核态，去调用操作系统（Kernel）的读能力，将数据读入内核缓冲区。这期间用户线程
阻塞，操作系统使用 DMA（Direct Memory Access）来实现文件读，其间也不会使用 CPU

DMA 也可以理解为硬件单元，用来解放 cpu 完成文件 IO

从内核态切换回用户态，将数据从内核缓冲区读入用户缓冲区（即 byte[] buf），这期间 CPU 会参与拷贝，无法利用 DMA
调用 write 方法，这时将数据从用户缓冲区（byte[] buf）写入 socket 缓冲区，CPU 会参与拷贝
接下来要向网卡写数据，这项能力 Java 又不具备，因此又得从用户态切换至内核态，调用操作系统的写能力，使用 DMA 将 socket 缓冲区的数据写入网卡，不会使用 CPU

可以看到中间环节较多，java 的 IO 实际不是物理设备级别的读写，而是缓存的复制，底层的真正读写是操作系统来完成的

用户态与内核态的切换发生了 3 次，这个操作比较重量级
数据拷贝了共 4 次

NIO优化

通过 DirectByteBuf

ByteBuffer.allocate(10)
底层对应 HeapByteBuffer，使用的还是 Java 内存
ByteBuffer.allocateDirect(10)
底层对应DirectByteBuffer，使用的是操作系统内存

当我们在Java中发起一个文件读操作会发生什么呢？首先内核会将数据从磁盘读到内存，再从内核拷贝到用户态的堆外内存(这部分是jvm实现)，然后再将数据从堆外拷贝到堆内。拷贝到堆内其实就是我们在Java中自己手动申请的byte数组中。以上是Java传统io的方式，我们发现经过了俩次内存拷贝。而NIO中只需要使用directbuffer，就不必将数据从堆外拷贝到堆内了，减少了一次内存拷贝，降低了内存的占用，减轻了gc的压力。

这块内存不受 JVM 垃圾回收的影响，因此内存地址固定，有助于 IO 读写
Java 中的 DirectByteBuf 对象仅维护了此内存的虚引用，内存回收分成两步
- DirectByteBuffer 对象被垃圾回收，将虚引用加入引用队列
  - 当引用的对象ByteBuffer被垃圾回收以后，虚引用对象Cleaner就会被放入引用队列中，然后调用Cleaner的clean方法来释放直接内存
  - DirectByteBuffer 的释放底层调用的是 Unsafe 的 freeMemory 方法
- 通过专门线程访问引用队列，根据虚引用释放堆外内存
  减少了一次数据拷贝，用户态与内核态的切换次数没有减少

进一步优化1

以下两种方式都是零拷贝，即无需将数据拷贝到用户缓冲区中（JVM内存中）

底层采用了 linux 2.1 后提供的 sendFile 方法，Java 中对应着两个 channel 调用 transferTo/transferFrom 方法拷贝数据

Java 调用 transferTo 方法后，要从 Java 程序的用户态切换至内核态，使用 DMA将数据读入内核缓冲区，不会使用 CPU
数据从内核缓冲区传输到 socket 缓冲区，CPU 会参与拷贝
最后使用 DMA 将 socket 缓冲区的数据写入网卡，不会使用 CPU

其实就是在我们读取磁盘IO数据后，拷贝到内核缓冲区后，不需要再拷贝到java中的buffer中（用户缓冲区），而是直接拷贝到socket缓冲区中，写入网卡

这种方法下

只发生了1次用户态与内核态的切换
数据拷贝了 3 次

进一步优化2

linux 2.4 对上述方法再次进行了优化

Java 调用 transferTo 方法后，要从 Java 程序的用户态切换至内核态，使用 DMA将数据读入内核缓冲区，不会使用 CPU
只会将一些 offset 和 length 信息拷入 socket 缓冲区，几乎无消耗
使用 DMA 将 内核缓冲区的数据写入网卡，不会使用 CPU

整个过程仅只发生了1次用户态与内核态的切换，数据拷贝了 2 次。

所谓的【零拷贝】并不是真正的无拷贝，而是不会拷贝重复数据到JVM内存中，零拷贝的优势：

更少的用户态与内核态的切换
不利用cpu计算（利用DMA），减少cpu缓存伪共享
零拷贝适合小文件

posted @ 2021-07-25 22:28 刚刚好。阅读(114) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

刚刚好。

NIO笔记

NIO

Channel

FileChannel

获取

读取(往buffer里读)

写入（写入到channel中）

关闭

位置

强制写入

两个channel之间传输数据

Buffer

常见的buffer:

使用步骤

内部结构

核心方法

put()

flip()

get()

rewind()

clear()方法

mark()和reset()方法

compact()方法

clear() VS compact():

字符串与ByteBuffer的相互转换

方法一:

粘包与半包

现象

出现原因

解决办法

Selector

网络编程

阻塞

非阻塞

Selector

多路复用

步骤

断开处理

消息边界

ByteBuffer的大小分配

write事件

多线程优化

实现思路

实现代码

概念剖析

Stream与Channel

IO模式

阻塞IO

非阻塞IO

多路复用

异步非阻塞IO（AIO）

零拷贝

传统IO问题

NIO优化

进一步优化1

进一步优化2

公告