netty之NIO从浅入深、详细解析。

BIO:同步、阻塞

NIO:同步、非阻塞

AIO:异步、非阻塞

 

在学习NIO之前，需要大家先了解一些简单的概念：

1.cache（高速缓存）和buffer（缓冲区）：

cache缓存区和buffer缓冲区都是临时存储区。

buffer缓冲区主要存在于RAM中，作为CPU暂时存储数据的区域（当计算机和其他设备有不同的速度时，buffer存储着缓冲的数据，这样计算机就可以做其他应用了）

cache缓存区是一种高速存储区域，可以在主存或硬盘灯其他独立存储区域的一部分。

总结：cache高速缓存为硬盘缓存，buffer缓冲区被称为内存缓存。

 

2.阻塞（Block）和非阻塞（Non-Block）:

阻塞和非阻塞是进程在访问数据的时候，数据是否准备就绪的一种处理方式，当数据没有准备的时候

阻塞：往往需要等待缓冲区中的数据准备好过后才处理其他的事情，否则一直等待在哪里。

非阻塞：当我们的进程访问我们的数据缓冲区的时候，如果数据没有准备好则直接返回，不会等待。如果数据已经准备好，也直接放回。

 

3.同步（Synchronization）和异步（Asynchronous）的方式：

同步和异步都是基于应用程序和操作系统处理IO事件所采用的方式。

比如同步：是应用程序要直接参与IO读写的操作。

异步：所有的IO读写交给操作系统去处理，应用程序只需要等待通知。

同步方式在处理IO事件的时候，必须阻塞在某个方法上面等待我们的IO事件完成（阻塞IO事件或者通过轮询IO事件的方式），对于一部来说，所有的IO读写都交给了操作系统。这个时候，我们可以去做其他的事情，并不需要去完成真正的IO操作，当操作完成IO后会给我们的应用程序一个通知。

同步：阻塞到IO事件，阻塞到read或者write。这个时候我们就完全不能做自己的事情。让读写方法加入到线程里面，然后阻塞线程来实现，对线程的性能开销比较大。

4.BIO（Block IO）于NIO（Non-Block IO）对比：

IO模型	IO	NIO
方式	从硬盘到内存	从内存到硬盘
通信	面向流	面向缓冲
处理	阻塞IO（多线程）	非阻塞IO（反应堆Reactor）
触发	无	选择器（轮询机制）

 

5.面向流与面向缓冲：

Java NIO 和 IO 之间第一个最大区别是，IO是面向流的，NIO是面向缓冲区的。Java IO 面向流意味着每次从流中读取一个或多个字节，直至读取所有字节，他们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。Java NIO 的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。

 

6.socket（套接字）：Socket clinet = new Socket("localhost",8080)

网络上两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。

TCP/IP协议帮我们解决能够实现两台主机之间的进程通信，网络层的IP地址可以唯一标识网络中的主机，传输层的协议+端口可以唯一标识主机中的应用程序（进程），这样利用三元组（IP地址、协议、端口）就可以标识网络的进程。

NIO各没款详细解析

一、深入剖析 Buffer

在谈到缓冲区时，我们说缓冲区对象本质上是一个数组，但它其实是一个特殊的数组，缓冲区对象内置了一些机制，

能够跟踪和记录缓冲区的状态变化情况，如果我们使用get()方法从缓冲区获取数据后者使用put()方法把数据写入缓

冲区，都会引起缓冲区状态的变化。

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

 

position：指定了下一个将要被写入或者读取的元素索引，它的值由get()/put()方法自动更新，在新创建一个Buffer

对象时，position被初始化为0

capacity 数组容量

limit 可操作范围

position 标记/游标 get和put时候到哪个位置 相当于数组索引 index

flip() 把当前缓冲区固定

二、缓冲区的分配

1、分配指定带下的缓冲区

2、包装一个现有的数组 ByteBuffer.wrap(new byte[10])

3、缓冲区的切片 Slice 0<position<limit<capacity 在position和limit之间分成不同的子缓冲区

4、只读缓冲区 buffer.asReadOnlyBuffer() 这个缓冲区的数据不能put()只能get()

5、直接缓冲区 ByteBuffer.allocateDirect(1024) Java程序再怎么分配都是在JVM允许范围内分配（堆栈区），

类似C语言，直接调用C语言模块，最底层。从操作系统中直接分配内存，netty中的零拷贝。

6、内存映射文件I/O，在内存中可读可写，直接持久化硬盘

三、通道 Channel

通道是一个对象，通过它可以读取和写入数据，当然了所有数据都通过Buffer对象来处理。我们永远不会将字节直接

写入通道中，相反是将数据写入包含一个或者多个字节的缓冲区。同样不会直接从通道中读取字节，而是将数据从通

道读入缓冲区，再从缓冲区获取这个字节。在NIO中，提供了多种通道对象，而所有的通道对象都实现了Channel接口。

 

使用NIO读取数据

在前面我们说过，任何时候读取数据，都不是直接从通道读取，而是从通道读取到缓冲区。

所以使用NIO读取数据分为以下三个步骤：

1.从FileInputStream获取Channel

2.创建Buffer

3.将数据从Channel读取到Buffer中

 

四、反应堆 Reactor

 

1、阻塞I/O通信模型

加入现在你对阻塞I/O有一定的了解，我们知道阻塞I/O在调用InputStream.read()方法时是阻塞的，它会一直

等到数据到来时（或超时）才会返回；同样，在调用ServerSocket.accept()方法时，也会一直阻塞到有客户端

连接才会返回，每个客户端连接过来后，服务端都会启动一个线程去处理该客户端的请求。

缺点：

a.当客户端多时，会创建大量的处理线程。而且每个线程都要占用栈空间和cpu时间

b.阻塞可能带来频繁的上下文切换，而且大部分上下文切换是可能无意义的

2、Java NIO原理及通信模型

Java NIO是在jdk 1.4开始使用的，称为新的I/O或者是非阻塞式I/O

工作原理：

a.由一个专门的线程来处理所有的IO时间，并负责分发。

b.事件驱动机制：事件到的时候触发，而不是同步的去监视事件

c.线程通讯：线程之间通过wait,notify等方式通讯，保证每次上下文切换都是有意义的，减少不必要的线程切换

（每个线程的处理流程大概都是读取数据、解码、计算处理、编码、发送响应）

五、选择器 Selector

传统的Server/Clinet模式会基于trp（Thread pre Request），服务器会为每个客户端请求建立一个线程，由该线程单独

负责处理一个客户端请求。这种模式带来的一个问题是线程数据的剧增，大量的线程会增大服务器的开销。大多数的实现

为了避免这个问题，都采用了线程池模型，并设置线程池线程的最大数量，这又带来了新的问题，如果线程池中有200个线

程，而又200个用户都在进行大文件下载，会导致201个用户的请求无法及时处理，即便第201个用户只想请求一个几KB大小的页面。

NIO中非阻塞I/O采用了基于Reactor模式的工作方式，I/O调用不会被阻塞，相反是注册感兴趣的特定I/O事件，如可读数据

到达，新的套接字连接等等，在发生特定事件时，系统再通知我们。NIO中实现非阻塞I/O的核心对象就是Selector，Selector

就是注册各种I/O事件池，而且当那些事情发生时，就是这个对象告诉我们所发生的事件。

NIOServer代码：

package com.sinosoft.study.nio.demo;

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;
import java.util.Set;

public class NIOServer {

    private int port = 8080;
    private Selector selector;

    public NIOServer(int port){
        try{
            this.port = port;
            // ServerSocketChannel是一个可以监听新进来的TCP连接的通道，就像标准IO中的ServerSocket一样
            // 获得一个ServerSocket通道
            ServerSocketChannel server = ServerSocketChannel.open();

            // 默认为阻塞，手动改为非阻塞
            server.configureBlocking(false);

            // 将该通道对于的 ServerSocket 绑定到 port端口号
            server.socket().bind(new InetSocketAddress(port));

            // 获得一个通道选择器
            selector = Selector.open();
            /*
             * 将通道选择器和该通道绑定，并为该通道注册selectionKey.OP_ACCEPT事件
             * 注册该事件后，当事件到达的时候，selector.select()会返回，
             * 如果事件没有到达selector.select()会一直阻塞
             */
            server.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("服务器准备就绪，监听端口是："+ this.port);

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

    public void listen(){
        try {
            System.out.println("start server");
            // 轮询
            while (true) {
                // 当注册事件到达时，方法返回，否则该方法会一直阻塞
                int wait = this.selector.select();
                if(wait == 0){ continue;}

                // 获得selector中选中的迭代器，选中注册的事件
                Set<SelectionKey> keys = this.selector.selectedKeys();
                Iterator<SelectionKey> i = keys.iterator();
                while(i.hasNext()){
                    SelectionKey key = i.next();

                    process(key);
                    i.remove();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public void process(SelectionKey key) throws Exception {

        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 客户端请求连接事件
        if(key.isAcceptable()){
            ServerSocketChannel server = (ServerSocketChannel) key.channel();
            // 获得和客户端连接的通道
            SocketChannel client = server.accept();
            client.configureBlocking(false);
            // 在客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限
            client.register(selector,SelectionKey.OP_READ);
        }else if(key.isReadable()){
            SocketChannel client = (SocketChannel) key.channel();
            int len = client.read(buffer);
            if(len > 0){
                buffer.flip();
                String content = new String(buffer.array(),0,len);
                System.out.println(content);
                client.register(selector,SelectionKey.OP_WRITE);
            }
            buffer.clear();

        }else if(key.isWritable()){
            SocketChannel client = (SocketChannel) key.channel();
            buffer = buffer.wrap("Hello Wold".getBytes());
            client.read(buffer);

        }
    }

    public static void main(String[] args) {
        new NIOServer(8080).listen();
    }

}

BIO客户端代码：

package com.sinosoft.study.bio;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.UUID;

public class BIOClient {
    public static void main(String[] args) throws UnknownHostException, IOException{
        // 获取一个Socket通道
        Socket client = new Socket("localhost",8080);
        // 输入流通道打开
        OutputStream os = client.getOutputStream();

        String uuid = UUID.randomUUID().toString();
        System.out.println("要输出的内容为：" + uuid);
        os.write(uuid.getBytes());
        os.close();
        client.close();
    }
}

BIO服务端代码：

package com.sinosoft.study.bio;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class BIOServer {
    ServerSocket server;
    // 服务器
    public BIOServer(int port){
        try{
            // 把Socket服务端启动
            server = new ServerSocket(port);
            System.out.println("BIO服务已启动，监听的端口号是：" + port);
        }catch(IOException e){
            e.printStackTrace();
        }
    }
    /**
      * @Description: 开始监听，并处理逻辑
      * @Param: 
      * @return: 
      * @Author: Mr.WangYu
      * @Date: 2018/11/11
      * @Time: 14:29
      */
    public void listener() throws IOException{
        // 循环监听
        while(true){
            // 等待客户端的连接，阻塞方法
            Socket client = server.accept();

            InputStream is = client.getInputStream();
            byte []b = new byte[1024];
            int num = is.read(b);
            if (num > 0){
                String msg = new String(b,0,num);
                System.out.println("收到：" + msg);
            }
        }
    }

    public static void main(String[] args) throws IOException{
        new BIOServer(8080).listener();
    }
}

赠品：AIO服务端代码

package com.sinosoft.study.aio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

public class AIOServer {

    private int port = 8080;


    public AIOServer(int port){
        this.port = port;
    }
    public void listen(){
        try {
            AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open();
            server.bind(new InetSocketAddress(this.port));
            server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {

                @Override
                public void completed(AsynchronousSocketChannel client, Object attachment) {
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    client.read(buffer);
                    buffer.flip();
                    System.out.println("111111111111");
                    System.out.println(new String(buffer.array()));
                }

                @Override
                public void failed(Throwable exc, Object attachment) {

                }
            });
        }catch (Exception e){
            e.printStackTrace();
        }
        try {
            Thread.sleep(Integer.MAX_VALUE);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new AIOServer(8080).listen();
    }
}