NIO个人学习笔记

@Test
    public void Channel() throws Exception {
        File file = new File("");
        FileInputStream inputStream = new FileInputStream("123.png");
        FileChannel channel = inputStream.getChannel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);//jvm中创建缓冲区
//        ByteBuffer.allocateDirect(1024); 从内存中创建
        int read = channel.read(buffer);
        while (read != -1){
            System.out.println("读到了：" + read + "长度");
            /**
             * 源码：
             * limit = position;
             * position = 0;
             * mark = -1;
             */
            buffer.flip();//翻转模式，之前buffer是读模式，现在要切换到写模式
            while (buffer.hasRemaining()){
                System.out.println(buffer.get());
            }
            /**
             * 源码：
             * position = 0;
             * limit = capacity;
             * mark = -1;
             */
            buffer.clear();
            read = channel.read(buffer);
        }
    }

注意：这里调用get()方法之前调用了flip()方法，这个是必须的。具体说明请看buffer章节

四、Buffer（缓存）

当文件被读到Channel后，想要写入到另外一个地方，但是这不能直接写入的，这里就需要Buffer。缓冲器本质上是一块可以被写入数据，也可以被读取数据的内存；这块内存被NIO包装后就成为了Buffer对象。

1）用法

正如我们的上一个实例，

1.通过Channel的read()方法把数据写到Buffer中(对channel来说是读，对buffer来说是写)。

2.调用Buffer的flip()方法

3.从Buffer中获取数据

4.清空缓冲区

当我们把数据写到buffer中去，buffer会记录下我们写了多少数据进去，这时候buffer是读模式，我们要获取buffer中的数据就需要切换的读模式，这里就需要调动flip()方法进行模式的切换。

一旦读完所有的数据，我们就需要清空缓存中的数据，这样是为了让它可以再次被写入；这里有两个方法：

1.clear()，清除所有的数据(limit = capacity, position = 0)

2.compact()，清除已经读的数据(这里会计算capacity和limit的差然后赋值给position，建议去看下源码好理解一点)

2）capacity、limit和position

在用法上面说到了几个方法，他们都去改变了limit、position的值。这里就拿这几个属性来说下Buffer的原理。

其实buffer的底层就是数组去实现的，它额外映入了mark，position、limit、capacity概念。

a）capacity

它所记录的就是我们一开始开辟内存的大小，这个是固定的，一旦被写满后就需要清除，如果没有清除的话再写入数据就睡报错

b）position

position的初始值是0，当我们写入数据的时候position会记录我们把数据写到哪个位置了，当buffer从写模式切换到读模式后flip()方法，position值会立马被设置为0。

c）limit

在写模式下，limit就等于capacity的值，这表示我们能写多少个数据到buffer中去；当切换到读模式下，limit就是写模式下的position的值，这表示我们最多能读出来多少数据

3）Buffer类型

ByteBuffer
MappedByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer

4）示例

Buffer的方法有很多，我们通过代码来看一下

@Test
    public void testBuffer() throws Exception{
        FileChannel inChannel = FileChannel.open(Paths.get("123.png"), StandardOpenOption.READ);
        FileChannel outChannel = FileChannel.open(Paths.get("124.png"), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
        //分配缓冲区大小
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        //向buffer中写数据
        int read = inChannel.read(byteBuffer);
        while (read != -1){
            //反转模式 写模式到读模式
            byteBuffer.flip();
            //向通道里面写数据
            outChannel.write(byteBuffer);
            //清除缓冲区
            byteBuffer.clear();
            read = inChannel.read(byteBuffer);
        }
        inChannel.close();
        outChannel.close();
    }

五、Scatter/Gather（分散和聚集）

Scatter和Gather分别用于描述充Channel中读取和写入。

1）Scatter

Scatter是分散，是从Channel中读取写入到不同的Buffer中。

代码实例

        FileChannel inChannel = FileChannel.open(Paths.get("123.png"), StandardOpenOption.READ);
        ByteBuffer allocate1 = ByteBuffer.allocate((int) inChannel.size());
        ByteBuffer allocate2 = ByteBuffer.allocate((int) inChannel.size());
        ByteBuffer[] arr = {allocate1, allocate2};
        inChannel.read(arr);

注：首先将所有的Buffer放到一个数组中，然后将数组做为参数传入到read方法中，read方法会按数组的顺序一个一个的将数据写入到Buffer中

2）Gather

Gather是将多个个Buffer中的数据写入到一个Channel中

代码实例

        FileChannel outChannel = FileChannel.open(Paths.get("124.png"), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
        ByteBuffer allocate1 = ByteBuffer.allocate((int) inChannel.size());
        ByteBuffer allocate2 = ByteBuffer.allocate((int) inChannel.size());
        outChannel.write(arr);

arr作为参数传入到write方法中，这里写入也会按照数组的顺序依次写入，但是这里写入只会读取Buffer position到limit中的数据

六、Channel之间的数据传输

当我们创建好Channel之后，我们就可以在两个Channel之间进行数据的传输，但是必须又有个Channel是FileChannel

它主要通过两个方法去实现

1）transferFrom

/**
*src 元数据来自哪里
*position 从哪个位置开始写入
*count 写入多少
*/
public abstract long transferFrom(ReadableByteChannel src,
                                      long position, long count)
        throws IOException;

2）transferTo

public abstract long transferTo(long position, long count,
                                WritableByteChannel target)
    throws IOException;

3）示例

FileChannel inChannel = FileChannel.open(Paths.get("123.png"), StandardOpenOption.READ);
FileChannel outChannel = FileChannel.open(Paths.get("124.png"), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
inChannel.transferTo(0, inChannel.size(), outChannel);
outChannel.transferFrom(inChannel, 0, inChannel.size());

七、Selector

selector为我们提供了一个线程监控多个Channel，并能够知道某个通道具体干嘛，这样就让我们能够监听多个网络连接

1）为什么需要selector

首先我们的内存是有限的，多一条线程可能没什么太大的影响，但是线程越来越多的话，那么内存势必是不够用的。当用一个线程就可以管理所有Channel的时，那内存开销是不是就减少了很多呢？而且还省去了多个线程在CPU中的切换。

2）如何创建Selector

Selector open = Selector.open();

3）如何向Selector中注册Channel

之前说过，要像selector管理Channel就必须让Channel注册到selector中去。

        Selector selector = Selector.open();
        SocketChannel socketChannel = SocketChannel.open();
        //设置为非阻塞模式
        socketChannel.configureBlocking(false);
        //完成注册
        //这里注册需要设置好监听的对象
        //OP_CONNECT 连接
        //OP_ACCEPT 同意
        //OP_READ 读
        //OP_WRITE 写
        socketChannel.register(selector, SelectionKey.OP_READ, SelectionKey.OP_ACCEPT);

注：这里不能使用FileChannel，应为FileChannel不能被设置为非阻塞模式

4）示例

我们之前写的都是基于阻塞模式下的NIO，那么NIO是非阻塞的一个IO，那我们具体需要怎么做？

首先我们不能使用FileChannel，因为上面也说了FileChannel是没有方法把它切换到非阻塞模式下的，那么我们以SocketChannel为例说明

先写一个阻塞模式下的完全示例

@Test
    public void client() throws IOException {

        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8888));
        //分配内存空间
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        System.out.println(LocalDateTime.now().getDayOfWeek().toString());
        //读取数据
        buffer.put("发送数据".getBytes());
        //一定要切换模式，不然在write的时候是没有数据内容的
        buffer.flip();
        //发送到服务器
        int write = socketChannel.write(buffer);
        System.out.println(new String(buffer.array(), 0, write));
        //关闭通道
        socketChannel.close();
    }

    @Test
    public void server() throws IOException{
        ServerSocketChannel channel = ServerSocketChannel.open();
        //监听端口号
        channel.bind(new InetSocketAddress(8888));
        //获取channel
        SocketChannel socketChannel = channel.accept();
        //分配缓冲区大小
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //读到buffer中
        int length = socketChannel.read(buffer);
        //切换模式
        buffer.flip();
        //写出buffer中数据
        System.out.println("22" + new String(buffer.array(), 0, length));
        //关闭通道
        channel.close();
        socketChannel.close();
    }

为什么说这个是阻塞的呢，当我们服务端没有收到的时候，线程就一直在等待，那么就不能去干别的事情，客户端也是一样的

加入selector后的非阻塞式

@Test
    public void send() throws IOException {
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8888));
        socketChannel.configureBlocking(false);
        //分配内存空间
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        System.out.println(LocalDateTime.now().getDayOfWeek().toString());
        //读取数据
        buffer.put(LocalDateTime.now().getDayOfWeek().toString().getBytes());
        //一定要切换模式，不然在write的时候是没有数据内容的
        buffer.flip();
        //发送到服务器
        int write = socketChannel.write(buffer);
        System.out.println(new String(buffer.array(), 0, write));
        //关闭通道
        socketChannel.close();
    }

    @Test
    public void recver() throws IOException {
        ServerSocketChannel channel = ServerSocketChannel.open();
        //监听端口号
        channel.bind(new InetSocketAddress(8888));
        //获取channel
        channel.configureBlocking(false);
        Selector selector = Selector.open();
        channel.register(selector, SelectionKey.OP_ACCEPT);
        //用while循环是因为while循环可以改变长度 for循环做不到
        while (selector.select() > 0){
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey selectionKey = iterator.next();
                if (selectionKey.isAcceptable()){
                    SocketChannel socketChannel = channel.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ);
                } else if (selectionKey.isReadable()){
                    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    int len = 0;
                    if (( len = socketChannel.read(byteBuffer)) > 0){
                        byteBuffer.flip();
                        System.out.println(new String(byteBuffer.array(), 0, len));
                        byteBuffer.clear();
                    }

                }
            }
            //一定要romove 不然会一直有
            iterator.remove();
        }
        selector.close();
    }

注意，这里的selector是阻塞的

public void SelectorTest() throws Exception{
        Selector selector = Selector.open();
        SocketChannel socketChannel = SocketChannel.open();
        //设置为非阻塞模式
        socketChannel.configureBlocking(false);
        //完成注册
        //这里注册需要设置好监听的对象
        //OP_CONNECT 连接
        //OP_ACCEPT 同意
        //OP_READ 读
        //OP_WRITE 写
        socketChannel.register(selector, SelectionKey.OP_READ, SelectionKey.OP_ACCEPT);
        while(true) {
            int readyChannels = selector.selectNow();
            if (readyChannels == 0) continue;
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();
                if (key.isAcceptable()) {
                    // a connection was accepted by a ServerSocketChannel.
                } else if (key.isConnectable()) {
                    // a connection was established with a remote server.
                } else if (key.isReadable()) {
                    // a channel is ready for reading
                } else if (key.isWritable()) {
                    // a channel is ready for writing
                }
                keyIterator.remove();
            }
        }
    }

这只是一个学习笔记而已。为学习netty做基础