【netty基础】Java NIO三件套

在NIO中有三个核心对象需要掌握：缓冲区（Buffer）、选择器（Selector）和通道（Channel）。

一. 缓冲区

1．Buffer操作基本API

缓冲区其实是一个数组，在NIO库中，所有数据都是用缓冲区处理的。在读取数据时，从缓冲区中读；在写入数据时，它也是写入缓冲区的；任何时候访问NIO中的数据，都是将它放到缓冲区中。而在面向流I/O系统中，所有数据都是直接写入或者直接将数据读取到Stream对象中。

public class IntBufferDemo {
    
    
    public static void main(String[] args) {
    
    
        //1-----------------
        // 分配新的int缓冲区，参数为缓冲区容量
        // 新缓冲区的当前位置将为零，其界限(限制位置)将为其容量。它将具有一个底层实现数组，其数组偏移量将为零。
        IntBuffer buffer = IntBuffer.allocate(8);

        for (int i = 0; i < buffer.capacity(); ++i) {
    
    
            int j = 2 * (i + 1);
            // 将给定整数写入此缓冲区的当前位置，当前位置递增
            buffer.put(j);
        }
        // 重设此缓冲区，将限制设置为当前位置，然后将当前位置设置为0
        buffer.flip();
        // 查看在当前位置和限制位置之间是否有元素
        while (buffer.hasRemaining()) {
    
    
            // 读取此缓冲区当前位置的整数，然后当前位置递增
            int j = buffer.get();
            System.out.print(j + "  ");
        }
    }
}

在NIO中，所有的缓冲区类型都继承于抽象类Buffer，最常用的就是ByteBuffer，对于Java中的基本类型，基本都有一个具体Buffer类型与之相对应，它们之间的继承关系如下图所示。

2．Buffer的基本原理

Buffer缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况，如果我们使用get()方法从缓冲区获取数据或者使用put()方法把数据写入缓冲区，都会引起缓冲区状态的变化。

在缓冲区中，最重要的属性有下面三个，它们一起合作完成对缓冲区内部状态的变化跟踪。

• position：指定下一个将要被写入或者读取的元素索引，它的值由get()/put()方法自动更新，在新创建一个Buffer对象时，position被初始化为0。
• limit：指定还有多少数据需要取出（在从缓冲区写入通道时），或者还有多少空间可以放入数据（在从通道读入缓冲区时）。
• Capacity：指定了可以存储在缓冲区中的最大数据容量，实际上，它指定了底层数组的大小，或者至少是指定了准许我们使用的底层数组的容量。

以上三个属性值之间有一些相对大小的关系：0<=position<=limit<=capacity。

如果我们创建一个新的容量大小为10的ByteBuffer对象，在初始化的时候，position设置为0，limit和capacity设置为10，在以后使用ByteBuffer对象过程中，capacity的值不会再发生变化，而其他两个将会随着使用而变化。

import java.io.FileInputStream;
import java.nio.*;
import java.nio.channels.*;

/**
 * 了解buffer基本原理的例子
 */
public class BufferDemo {
    
    


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

        /**
         *初始化buffer ：
         *  分配一个10个大小缓冲区，说白了就是分配一个10byte大小的数组
         */
        ByteBuffer buffer = ByteBuffer.allocate(10);
        output("初始化", buffer);


        /**
         * 用io流创建管道
         */
        String userDir = System.getProperty("user.dir");
        String path = userDir + "/network-example/src/main/resources/netty-file/test.txt";
        //这用的是文件IO处理
        FileInputStream fin = new FileInputStream(path);
        //创建文件的操作管道
        FileChannel fc = fin.getChannel();


        /**
         * 1. 将管道的数据写入buffer中
         * 底层其实调用了buffer的put
         */
        fc.read(buffer);
        output("调用read()", buffer);

        //锁定：读取buffer的范围
        buffer.flip();
        output("调用flip()", buffer);

        //判断有没有可读数据
        while (buffer.remaining() > 0) {
    
    
            //get:一个字节一个字节的调用
            //每调用一次，Postion就更新一次
            byte b = buffer.get();
            System.out.println(((char) b));
        }
        output("调用get()", buffer);

        //解锁：所有位置恢复到初始化之前
        buffer.clear();
        output("调用clear()", buffer);

        //最后把管道关闭
        fin.close();
    }

    //把这个缓冲里面实时状态给答应出来
    public static void output(String step, ByteBuffer buffer) {
    
    
        System.out.println(step + " : ");
        //容量，数组大小
        System.out.print("capacity: " + buffer.capacity() + ", ");
        //当前操作数据所在的位置，也可以叫做游标
        System.out.print("position: " + buffer.position() + ", ");
        //锁定值，flip，数据操作范围索引只能在position - limit 之间
        System.out.println("limit: " + buffer.limit());
        System.out.println();
    }
}

2.1. put操作

从通道中读取一些数据到缓冲区中，注意从通道读取数据，相当于往缓冲区写入数据
写入4个byte的数据，position更新为4，即下一个将要被写入的字节索引为4，而limit仍然是10。

2.2. get操作

从缓冲区中读取数据，在此之前，必须调用flip()方法。
方法将会完成以下两件事情：一是把limit设置为当前的position值。二是把position设置为0。如下源码：

public final Buffer flip() {
    
    
    limit = position;
    position = 0;
    mark = -1;
    return this;
}

即锁定当前缓存区存在的数据范围，从position开始，然后到limit结束。

调用get()方法从缓冲区中读取数据写入输出通道，此时position增加而limit保持不变，但position不会超过limit的值，所以在读取之前写入缓冲区的4字节之后，position和limit的值都为4，如下图所示。

 

2.3. clear()回到初始化buffer的值

在从缓冲区中读取数据完毕后，limit的值仍然保持在调用flip()方法时的值，调用clear()方法能够把所有的状态变化设置为初始化时的值，如下图所示。

 
 

3．缓冲区的分配

在创建一个缓冲区对象时，会调用静态方法allocate()来指定缓冲区的容量，其实调用allocate()方法相当于创建了一个指定大小的数组，并把它包装为缓冲区对象。或者我们也可以直接将一个现有的数组包装为缓冲区对象，示例代码如下。

/**
 * 手动分配缓冲区
 */
public class BufferWrap {
    
      
    
    public void myMethod() {
    
      
        // 分配指定大小的缓冲区  
        ByteBuffer buffer1 = ByteBuffer.allocate(10);  
          
        // 包装一个现有的数组  
        byte array[] = new byte[10];  
        ByteBuffer buffer2 = ByteBuffer.wrap( array );
    } 
}

 
 

4．缓冲区分片

在NIO中，还在现有缓冲区上切出一片作为一个新的子缓冲区，但现有的缓冲区与创建的子缓冲区在底层数组层面上是数据共享的，也就是说，子缓冲区相当于现有缓冲区的一个视图窗口。

调用slice()方法可以创建一个子缓冲区，下面我们通过例子来看一下。

/**
 * 缓冲区分片
 */
public class BufferSlice {
    
    
    static public void main(String args[]) {
    
    
        ByteBuffer buffer = ByteBuffer.allocate(10);

        // 缓冲区中的数据0-9  
        for (int i = 0; i < buffer.capacity(); ++i) {
    
    
            buffer.put((byte) i);
        }

        // 创建子缓冲区  
        buffer.position(3);
        buffer.limit(7);
        ByteBuffer slice = buffer.slice();
        // 改变子缓冲区的内容  
        for (int i = 0; i < slice.capacity(); ++i) {
    
    
            byte b = slice.get(i);
            b *= 10;
            slice.put(i, b);
        }

        //遍历父buffer，也会遍历到更新的子buffer
        buffer.position(0);
        buffer.limit(buffer.capacity());
        while (buffer.remaining() > 0) {
    
    
            System.out.println(buffer.get());
        }
    }
}

 
 

5．只读缓冲区

只读缓冲区非常简单，可以读取它们，但是不能向它们写入数据。可以通过调用缓冲区的asReadOnlyBuffer()方法，将任何常规缓冲区转换为只读缓冲区，这个方法返回一个与原缓冲区完全相同的缓冲区，并与原缓冲区共享数据，只不过它是只读的。

如果原缓冲区的内容发生了变化，只读缓冲区的内容也随之发生变化。

/**
 * 只读缓冲区
 */
public class ReadOnlyBuffer {
    
    
    public static void main(String args[]) throws Exception {
    
    
        ByteBuffer buffer = ByteBuffer.allocate(10);

        // 缓冲区中的数据0-9  
        for (int i = 0; i < buffer.capacity(); ++i) {
    
    
            buffer.put((byte) i);
        }

        // 创建只读缓冲区  
        ByteBuffer readonly = buffer.asReadOnlyBuffer();

        // 改变原缓冲区的内容  
        for (int i = 0; i < buffer.capacity(); ++i) {
    
    
            byte b = buffer.get(i);
            b *= 10;
            buffer.put(i, b);
        }

        readonly.position(0);
        readonly.limit(buffer.capacity());

        // 只读缓冲区的内容也随之改变  
        while (readonly.remaining() > 0) {
    
    
            System.out.println(readonly.get());
        }
    }
}

如果尝试修改只读缓冲区的内容，则会报ReadOnlyBufferException异常。只读缓冲区对于保护数据很有用。

6. 直接(direct)缓冲区

直接缓冲区是为加快I/O速度，使用一种特殊方式为其分配内存的缓冲区，JDK文档中的描述为：给定一个直接字节缓冲区，Java虚拟机将尽最大努力直接对它执行本机I/O操作。

也就是说，它会在每一次调用底层操作系统的本机I/O操作之前（或之后），尝试避免将缓冲区的内容拷贝到一个中间缓冲区或者从一个中间缓冲区拷贝数据。要分配直接缓冲区，需要调用allocateDirect()方法，使用方式与普通缓冲区并无区别，如下面的文件所示。

import java.io.*;
import java.nio.*;
import java.nio.channels.*;


/**
 * 直接缓冲区
 * Zero Copy 减少了一个拷贝的过程
 */
public class DirectBuffer {
    
    
    static public void main(String args[]) throws Exception {
    
    

        //io流创建输入源
        String userDir = System.getProperty("user.dir");
        String infile = userDir + "/network-example/src/main/resources/netty-file/test.txt";
        FileInputStream fin = new FileInputStream(infile);
        FileChannel fcin = fin.getChannel();

        //io流创建输出源
        String outfile = userDir + "/network-example/src/main/resources/netty-file/test-out.txt";
        FileOutputStream fout = new FileOutputStream(outfile);
        FileChannel fcout = fout.getChannel();

        // 使用allocateDirect
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

        while (true) {
    
    
            //位置初始化
            buffer.clear();
            //buffer 写入
            int r = fcin.read(buffer);
            if (r == -1) break;
            buffer.flip();
            //buffer 写出：从零开始读
            fcout.write(buffer);
        }
    }
}

7. 内存映射

内存映射是一种读和写文件数据的方法，可以比常规的基于流或者基于通道的I/O快得多。
只有文件中实际读取或写入的部分才会映射到内存中。来看下面的示例代码。

/**
 * IO映射缓冲区
 */
public class MappedBuffer {
    
    
    static private final int start = 0;
    static private final int size = 26;

    static public void main(String args[]) throws Exception {
    
    
        String userDir = System.getProperty("user.dir");
        String infile = userDir + "/network-example/src/main/resources/netty-file/test.txt";
        RandomAccessFile raf = new RandomAccessFile(infile, "rw");
        FileChannel fc = raf.getChannel();

        //把缓冲区跟文件系统进行一个映射关联

        MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, start, size);
        //只要操作缓冲区里面的内容，文件内容也会跟着改变
        mbb.put(0, (byte) 98);  //a
        mbb.put(25, (byte) 122);   //z


        raf.close();
    }
}

 
 

二. 选择器

TPR的问题

传统的Client/Server模式会基于TPR（Thread per Request），服务器会为每个客户端请求建立一个线程，由该线程单独负责处理一个客户请求。这种模式带来的一个问题就是线程数量的剧增，大量的线程会增大服务器的开销。

解决TPR的问题

大多数的实现为了避免这个问题，都采用了线程池模型，并设置线程池中线程的最大数量，这又带来了新的问题，如果线程池中有200个线程，而有200个用户都在进行大文件下载，会导致第201个用户的请求无法及时处理，即便第201个用户只想请求一个几KB大小的页面。

传统的Client/Server模式如下图所示。

 
NIO中非阻塞I/O采用了基于Reactor模式的工作方式，I/O调用不会被阻塞，而是注册感兴趣的特定I/O事件，如可读数据到达、新的套接字连接等，在发生特定事件时，系统再通知client。
NIO中实现非阻塞I/O的核心对象是Selector，Selector是注册各种I/O事件的地方，而且当那些事件发生时，Selector就会告诉我们所发生的事件，如下图所示。

从图中可以看出，当有读或写等任何注册的事件发生时，可以从Selector中获得相应的SelectionKey（需要不停的调用select方法，其中select方法是堵塞的），同时从SelectionKey中可以找到发生的事件和该事件所发生的具体的SelectableChannel，以获得客户端发送过来的数据。

使用NIO中非阻塞I/O编写服务器处理程序，大体上可以分为下面三个步骤。

（1）向Selector对象注册感兴趣的事件；
（2）从Selector中获取感兴趣的事件；
（3）当时间事件发生时，进行相应的处理。

向Selector对象注册感兴趣的事件。

/**
 * //相当于开启一个server端，并绑定为一个端口，用于客户端向此发起请求
 * //其中这个server端，是非阻塞的，selector帮助server端监听事件，并当事件到来时处理事件
 */
private Selector getSelector() throws IOException {
    
    
    //创建selector对象
    Selector selector = Selector.open();

    //创建 可选择通道并配置为非阻塞式
    
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    serverSocketChannel.configureBlocking(false);

    //给通道绑定指定端口
    ServerSocket socket = serverSocketChannel.socket();
    InetSocketAddress inetSocketAddress = new InetSocketAddress(9999);
    socket.bind(inetSocketAddress);

    //向selector注册感兴趣的事件：select会监听accept事件
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    return selector;

}

从Selector中获取感兴趣的事件，通过不断的循环，开始监听，当能获取到SelectionKey时，说明有事件发生，接着通过process(key)方法处理事件。

public void listen() {
    
    
    System.out.println("listen on " + this.port + ".");
    try {
    
    
        //轮询主线程
        while (true) {
    
    
            //首先调用select()方法，该方法会阻塞，直到至少有一个事件发生
            selector.select();
            //获取所有的事件
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> iter = keys.iterator();
            //同步的体现：因为每次只能拿一个key，每次只能处理一种状态
            while (iter.hasNext()) {
    
    
                SelectionKey key = iter.next();
                iter.remove();
                //每一个key代表一种状态时间，进行处理： 数据就绪、数据可读、数据可写 等等等等
                process(key);
            }
        }
    } catch (IOException e) {
    
    
        e.printStackTrace();
    }
}

在非阻塞I/O中，内部循环模式基本都遵循这种方式。首先调用select()方法，该方法会阻塞，直到至少有一个事件发生，然后使用selectedKeys()方法获取发生事件的SelectionKey，再使用迭代器进行循环。

 
最后一步就是根据不同的事件，编写相应的处理代码。

//具体办业务的方法，坐班柜员
//每一次轮询就是调用一次process方法，而每一次调用，只能干一件事，即在同一时间点，只能干一件事
private void process(SelectionKey key) throws IOException {
    
    
    //针对于每一种状态给一个反应
    if (key.isAcceptable()) {
    
    
        ServerSocketChannel server = (ServerSocketChannel) key.channel();
        //这个方法体现非阻塞，不管你数据有没有准备好，你给我一个状态和反馈
        SocketChannel channel = server.accept();
        //一定一定要记得设置为非阻塞
        channel.configureBlocking(false);
        //当数据准备就绪的时候，将状态改为可读
        key = channel.register(selector, SelectionKey.OP_READ);
    } else if (key.isReadable()) {
    
    
        //从多路复用器中拿到客户端的引用
        SocketChannel channel = (SocketChannel) key.channel();
        int len = channel.read(buffer);
        if (len > 0) {
    
    
            buffer.flip();
            String content = new String(buffer.array(), 0, len);
            key = channel.register(selector, SelectionKey.OP_WRITE);
            //在key上携带一个附件，一会再写出去
            key.attach(content);
            System.out.println("读取内容：" + content);
        }
    } else if (key.isWritable()) {
    
    
        SocketChannel channel = (SocketChannel) key.channel();
        String content = (String) key.attachment();
        channel.write(ByteBuffer.wrap(("输出：" + content).getBytes()));
        channel.close();
    }
}

此处判断是接受请求、读数据还是写事件，分别做不同的处理。

在Java 1.4之前的I/O系统中，提供的都是面向流的I/O系统，系统一次一个字节地处理数据，一个输入流产生一个字节的数据，一个输出流消费一个字节的数据，面向流的I/O速度非常慢；

而在Java 1.4中推出了NIO，这是一个面向块的I/O系统，系统以块的方式处理数据，每一个操作在一步中都产生或者消费一个数据库，按块处理数据要比按字节处理数据快得多。

三. 通道

通道是一个对象，通过它可以读取和写入数据，当然所有数据都通过Buffer对象来处理。

我们永远不会将字节直接写入通道，而是将数据（从管道中）写入包含一个或者多个字节的缓冲区。同样也不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。

NIO提供了多种通道对象，所有的通道对象都实现了Channel接口。它们之间的继承关系如下图所示。

1．使用NIO写入数据

任何时候读取数据，都不是直接从通道读取的，而是从通道读取到缓冲区的。
使用NIO读取数据可以分为下面三个步骤。

（1）从FileInputStream获取Channel。
（2）创建Buffer。
（3）将数据加载到Buffer，然后通过channel写到文件中.

/**
 * 管道与buffer的配合1
 */
public class FileOutputDemo {
    
    
    static private final byte message[] = {
    
    83, 111, 109, 101, 32, 98, 121, 116, 101, 115, 46};

    static public void main(String args[]) throws Exception {
    
    
        String userDir = System.getProperty("user.dir");
        String infile = userDir + "/network-example/src/main/resources/netty-file/test.txt";
        FileOutputStream fout = new FileOutputStream(infile);

        FileChannel fc = fout.getChannel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        for (int i = 0; i < message.length; ++i) {
    
    
            buffer.put(message[i]);
        }
        buffer.flip();
        fc.write(buffer);
        fout.close();
    }
}

2．使用NIO读取数据

（1）从FileInputStream获取Channel。
（2）创建Buffer。
（3）将数据从Channel写入Buffer，然后进行输出

/**
 * buffer与channel
 * （1）从FileInputStream获取Channel。
 * （2）创建Buffer。
 * （3）将数据从Channel写入Buffer。
 */
public class FileInputDemo {
    
    


    static public void main(String args[]) throws Exception {
    
    
        String userDir = System.getProperty("user.dir");
        String infile = userDir + "/network-example/src/main/resources/netty-file/test.txt";
        FileInputStream fin = new FileInputStream(infile);

        // 获取通道  
        FileChannel fc = fin.getChannel();

        // 创建缓冲区  
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        // 读取数据到缓冲区  
        fc.read(buffer);
        buffer.flip();

        while (buffer.remaining() > 0) {
    
    
            byte b = buffer.get();
            System.out.print(((char) b));
        }
        fin.close();
    }
}

从nio写入、读取数据的示例中，可以知道channel作为数据源与buffer之间的管道，实现了buffer与外界对接数据的能力。

3. 多路复用I/O

多路复用的现实场景

客人到店后，自己申请一本菜单。想好自己要点的菜后，就呼叫服务员。
服务员站在自己身边记录客人的菜单内容。将菜单递给厨师的过程也要进行改进，
并不是每一份菜单记录好以后，都要交给后堂厨师。服务员可以记录好多份菜单后，同时交给厨师就行了。
那么这种方式，对于老板来说人力成本是最低的；
对于客人来说，虽然不再享受VIP服务，并且要进行一段时间的等待，但是这些都是可以接受的；
对于服务员来说，基本上她的时间都没有浪费，最大程度地提高了时间利用率。

技术选择：
目前流行的多路复用I/O的实现主要包括四种：select、poll、epoll、kqueue。如下表所示是它们的一些重要特性的比较。

多路复用I/O技术最适用的是“高并发”场景，所谓“高并发”是指1ms内至少同时有上千个连接请求准备好。其他情况下多路复用I/O技术发挥不出它的优势。另外，使用Java NIO进行功能实现，相对于传统的套接字实现要复杂一些，所以实际应用中，需要根据自己的业务需求进行技术选择。

 
 
参考：
《Netty4核心原理与手写RPC框架》