分布式复习-NIO

基本概念：

1,InputStream 与Outputstream

   InputStram与OutputStream是相对于内存来说的

2,阻塞 bloker 和非阻塞 Non-bloker

       阻塞和非阻塞是针对数据而言的，是指 进程在访问数据的时候，数据是否就绪的一种处理方式。

阻塞； 当数据没有准备就绪的时候 ，往往需要等待缓冲区中的数据准备好过后才处理其他的事情，否则会一直等待在哪里。

非阻塞：当进程访问数据缓冲区时，如果数据没有准备就绪的时候 直接返回，不会等待，继续往下执行。如果数据已准备好，处理数据，直接返回

3,同步 Synchronization 和 异步  Asynchronous 的方式

        宽泛的将 异步是在做某件事情的同时还可以做其他的事情。同步在同一时间点程序只做一件事情

       在这里是io中的    同步 异步 是指基于应用程序和操作系统处理IO事件所采用的方式。

  同步：应用程序之间参与IO读写的操作。异步：所有的IO读写交给操作系统去完成，应用程序只需要等待通知。

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

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

 

BIO  与 NIO 的对比

IO模型	io	nio
通信	面向流（乡村公路）	面向缓冲区（高速公路，多路复用）
处理	阻塞IO（多线程）	非阻塞IO(反应堆 Reactor)
触发	无	选择器（轮询机制）

 

BIO 可以使用线程池改造

 

main(
   ServerSocker socker=null;

ExecuterService executerService=Executors.newFixedThreadPool(60);
   try(){
     socket=new ServerSocker(port:8080);
     system.out.p("服务器启动成功，监听端口为8000，等待端连接。。。")
     while(true){
       Socket socket=Socker.accept();
        //使用线程池中的线程去执行每个对应的任务
         executerService.execute(new ServerHandler(socket));
     }
   }

)

 

局限： 1  accept()方法是阻塞的

            2  IO的局限 是面向流stream的,阻塞的 串行的一个过程

            3，高并发情况下 client与server端建立连接时也可能发生阻塞。

            4，在使用线程池改造bio之前，service端点的线程数是不可控的，多少个client 多少个runable就可能有 多少个线程。

 

NIO

 

 

缓冲区 Buffer

 

        

 

 

缓冲区（Buffer）

通过上面NIO与普通IO的主要区别也可以看到在基本的IO操作中所有的操作都是基于流进行操作的，而在NIO中所有的操作都是基于缓冲区继续操作的，所有的读写操作都是通过缓存区来进行完成，缓冲区（Buffer）是一个线性的、有序的数据集，只能容纳特定的数据类型（基本就是基本数据类型对应的Buffer或者起子类）。

各各数据类型的缓存区类

缓存区类|相关描述 
|:——–:|:———-:| 
ByteBuffer|存储字节的Buffer 
CharBuffer|存储字符的Buffer 
ShortBuffer|存储短整型的Buffer 
IntBuffer|存储整型的Buffer 
LongBuffer|存储长整型的Buffer 
FloatBuffer|存储单精度浮点型Buffer 
DoubleBuffer|存储双精度浮点型Buffer

备注：看到上面这几类是不是想起了JAVA的8种基本数据类型，唯一缺少boolean对于的类型。

第一问：为什么boolean不需要缓存呢？ 
可以查阅之前写的：java二进制相关基础，里面有描述规范中数字的内部表示和存储，boolean所占位数1bit（取值只有true或者false），由于字节(byte)是操作系统和所有I/O设备使用的基本数据类型，所以基本都是以字节或者连续的一段字节来存储表示，所以就没有boolean，感觉也没有必要boolean类型的缓存操作（像RocketMQ源码里面可能把一个Int里面的某位来表示boolean，其他位继续来存储数据，欢迎关注我的公众号【匠心零度】，后续RocketMQ源码类分析的时候如何运用上述技巧进行说明等，其实上面我写的好几篇文章都是为了后续RocketMQ源码分析做准备的）。

Buffer使用

读数据： 
- flip()方法 
- 将Buffer从写模式切换到读模式 
- 调用flip()方法会将position设回0，并将limit设置成之前position的值。 
- buf.flip(); 
- buf.get() 
- 读取数据 
- Buffer.rewind() 
- 将position设回0，所以你可以重读Buffer中的所有数据 
- limit保持不变，仍然表示能从Buffer中读取多少个元素（byte、char等） 
- Buffer.mark()方法，可以标记Buffer中的一个特定position。之后可以通过调用。 
- Buffer.reset()方法，恢复到Buffer.mark()标记时的position。 
- clear()方法会： 
- 清空整个缓冲区。 
- position将被设回0，limit被设置成 capacity的值 
- compact()方法： 
- 只会清除已经读过的数据；任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。 
- 将position设到最后一个未读元素正后面，limit被设置成 capacity的值。

写数据： 
buf.put(127);

缓冲区的基本属性

• 容量 (capacity):表示 Buffer 最大数据容量，缓冲区容量不能为负，并且创建后不能更改。
• 限制 (limit):第一个不应该读取或写入的数据的索引，即位于 limit 后的数据不可读写。缓冲区的限制不能为负，并且不能大于其容量。
• 位置 (position):下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制。

备注：标记、 位置、 限制、 容量遵守以下不变式： 0 <= position <= limit <= capacity。

为了更形象解释上面重要属性，准备配上简单代码以及图来进行说明就容易懂了。

//第一步，获取IntBuffer，通过IntBuffer.allocate操作
IntBuffer buf = IntBuffer.allocate(10) ;    // 准备出10个大小的缓冲区

//第二步未操作前输出属性值
System.out.println("position = " + buf.position() + "，limit = " + buf.limit() + "，capacty = " + buf.capacity()) ;

//第三步进行设置数据
buf.put(6) ;    // 设置一个数据
buf.put(16) ;   // 设置二个数据

//第四步操作后输出属性值
System.out.println("position = " + buf.position() + "，limit = " + buf.limit() + "，capacty = " + buf.capacity()) ;

//第五步将Buffer从写模式切换到读模式 postion = 0 ,limit = 原本position
buf.flip() ;     

//第六步操作后输出属性值
System.out.println("position = " + buf.position() + "，limit = " + buf.limit() + "，capacty = " + buf.capacity()) ;

程序输出结果：

position = 0，limit = 10，capacty = 10
position = 2，limit = 10，capacty = 10
position = 0，limit = 2，capacty = 10

查看下图来进行说明：

通道（Channel）

通道表示打开到 IO 设备(例如：文件、套接字)的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。Channel 负责传输， Buffer 负责存储。通道是由 java.nio.channels 包定义的。 Channel 表示 IO 源与目标打开的连接。Channel 类似于传统的“流”。只不过 Channel本身不能直接访问数据， Channel 只能与Buffer 进行交互。

通道都是操作缓存区完成全部的功能的。

Java中所有已知 Channel 实现类：

• AbstractInterruptibleChannel
• AbstractSelectableChannel
• DatagramChannel
• FileChannel
• Pipe.SinkChannel
• Pipe.SourceChannel
• SelectableChannel
• ServerSocketChannel
• SocketChannel

常用的有入下几个： 
- FileChannel：用于读取、写入、映射和操作文件的通道。 
- DatagramChannel：通过 UDP 读写网络中的数据通道。 
- SocketChannel：通过 TCP 读写网络中的数据。 
- ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。

获取通道

获取通道的一种方式是对支持通道的对象调用getChannel() 方法。支持通道的类如下： 
- FileInputStream 
- FileOutputStream 
- RandomAccessFile 
- DatagramSocket 
- Socket 
- ServerSocket

获取通道的其他方式是使用 Files 类的静态方法 newByteChannel() 获取字节通道。或者通过通道的静态方法 open() 打开并返回指定通道。

FileChannel

• 为了更形象解释说明的Channel，下面准备以FileChannel的一些简单代码进行说明就容易懂了。
• 准备以FileOutputStream类为准，这两个类都是支持通道操作的。

String info[] = {"欢迎","关注","匠心零度","的","公众号","谢谢！！"} ;
File file = new File("d:" + File.separator + "testfilechannel.txt") ; 
FileOutputStream output = null ;
FileChannel fout = null;
try {
    output = new FileOutputStream(file) ;
    fout = null;
    fout = output.getChannel() ;    // 得到输出的通道
    ByteBuffer buf = ByteBuffer.allocate(1024) ; 
    for(int i=0;i<info.length;i++){
        buf.put(info[i].getBytes()) ;   // 字符串变为字节数组放进缓冲区之中
    }
    buf.flip() ;
    fout.write(buf) ;   // 输出缓冲区的内容
} catch (Exception e) {
    e.printStackTrace();
}finally{
    if(fout!=null){
        try {
            fout.close() ;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    if(output!=null){
        try {
            output.close() ;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

程序运行效果：

Selector

说明： 
- FileChannel是可读可写的Channel，它必须阻塞，不能用在非阻塞模式中。 
- SocketChannel与FileChannel不同：新的Socket Channel能在非阻塞模式下运行并且是可选择的。不再需要为每个socket连接指派线程了。使用新的NIO类，一个或多个线程能管理成百上千个活动的socket连接，使用Selector对象可以选择可用的Socket Channel。

以前的Socket程序是阻塞的，服务器必须始终等待客户端的连接，而NIO可以通过Selector完成非阻塞操作。

备注：其实NIO主要的功能是解决服务端的通讯性能。 

Selector一些主要方法：

方法|说明 
|:——-:|:———:| 
open()|打开一个选择器。 
select()|选择一组键，其相应的通道已为 I/O 操作准备就绪。 
selectedKeys()|返回此选择器的已选择键集。

SelectionKey的四个重要常量：

字段|说明 
|:——-:|:———:| 
OP_ACCEPT | 用于套接字接受操作的操作集位。 
OP_CONNECT | 用于套接字连接操作的操作集位。 
OP_READ |用于读取操作的操作集位。 
OP_WRITE |用于写入操作的操作集位。

说明：其实四个常量就是Selector监听SocketChannel四种不同类型的事件。

如果你对不止一种事件感兴趣，那么可以用”位或”操作符将常量连接起来，如下： 
int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

NIO 简单实例代码

服务端代码：

int port = 8000;
// 通过open()方法找到Selector
Selector selector = Selector.open();
// 打开服务器的通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
// 服务器配置为非阻塞
serverSocketChannel.configureBlocking(false);
ServerSocket serverSocket = serverSocketChannel.socket();
InetSocketAddress address = new InetSocketAddress(port);
// 进行服务的绑定
serverSocket.bind(address);
// 注册到selector，等待连接
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("服务器运行，端口：" + 8000);

// 数据缓冲区
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

while (true) {
if ((selector.select()) > 0) { // 选择一组键，并且相应的通道已经准备就绪
    Set<SelectionKey> selectedKeys = selector.selectedKeys();// 取出全部生成的key
    Iterator<SelectionKey> iter = selectedKeys.iterator();
    while (iter.hasNext()) {
        SelectionKey key = iter.next(); // 取出每一个key
        if (key.isAcceptable()) {
            ServerSocketChannel server = (ServerSocketChannel) key.channel();
            // 接收新连接 和BIO写法类是都是accept
            SocketChannel client = server.accept();
            // 配置为非阻塞
            client.configureBlocking(false);
            byteBuffer.clear();
            // 向缓冲区中设置内容
            byteBuffer.put(("当前的时间为：" + new Date()).getBytes());
            byteBuffer.flip();
            // 输出内容
            client.write(byteBuffer);
            client.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable() && key.isValid()) {
            SocketChannel client = (SocketChannel) key.channel();
            byteBuffer.clear();
            // 读取内容到缓冲区中
            int readSize = client.read(byteBuffer);
            if (readSize > 0) {
                System.out.println("服务器端接受客户端数据:" + new String(byteBuffer.array(), 0, readSize));
                client.register(selector, SelectionKey.OP_WRITE);
            }
        } else if (key.isWritable() && key.isValid()) {
            SocketChannel client = (SocketChannel) key.channel();
            byteBuffer.clear();
            // 向缓冲区中设置内容
            byteBuffer.put(("欢迎关注匠心零度，已经收到您的反馈，会第一时间回复您。感谢支持！！！").getBytes());
            byteBuffer.flip();
            // 输出内容
            client.write(byteBuffer);
            client.register(selector, SelectionKey.OP_READ);
        }
    }
    selectedKeys.clear(); // 清楚全部的key
}
}

 

 

客户端代码：

// 打开socket通道
SocketChannel socketChannel = SocketChannel.open();
// 设置为非阻塞方式
socketChannel.configureBlocking(false);
// 通过open()方法找到Selector
Selector selector = Selector.open();
// 注册连接服务端socket动作
socketChannel.register(selector, SelectionKey.OP_CONNECT);
// 连接
socketChannel.connect(new InetSocketAddress("127.0.0.1", 8000));

/* 数据缓冲区 */
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

while (true) {
if ((selector.select()) > 0) { // 选择一组键，并且相应的通道已经准备就绪
    Set<SelectionKey> selectedKeys = selector.selectedKeys();// 取出全部生成的key
    Iterator<SelectionKey> iter = selectedKeys.iterator();
    while (iter.hasNext()) {
        SelectionKey key = iter.next(); // 取出每一个key
        if (key.isConnectable()) {
            SocketChannel client = (SocketChannel) key.channel();
            if (client.isConnectionPending()) {
                client.finishConnect();
                byteBuffer.clear();
                // 向缓冲区中设置内容
                byteBuffer.put(("isConnect,当前的时间为：" + new Date()).getBytes());
                byteBuffer.flip();
                // 输出内容
                client.write(byteBuffer);
            }
            client.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable() && key.isValid()) {
            SocketChannel client = (SocketChannel) key.channel();
            byteBuffer.clear();
            // 读取内容到缓冲区中
            int readSize = client.read(byteBuffer);
            if (readSize > 0) {
                System.out.println("客户端接受服务器端数据:" + new String(byteBuffer.array(), 0, readSize));
                client.register(selector, SelectionKey.OP_WRITE);
            }
        } else if (key.isWritable() && key.isValid()) {
            SocketChannel client = (SocketChannel) key.channel();
            byteBuffer.clear();
            // 向缓冲区中设置内容
            byteBuffer.put(("nio文章学习很多！").getBytes());
            byteBuffer.flip();
            // 输出内容
            client.write(byteBuffer);
            client.register(selector, SelectionKey.OP_READ);
        }
    }
    selectedKeys.clear(); // 清楚全部的key
}
}

程序运行结果截图：

说明：上面仅仅是一个demo，其实使用nio开发复杂度很高的，需要考虑：链路的有效性校验机制（安全认证、半包和粘包等）、链路的断连重连机制（网络闪断重连）、可靠性设计（心跳检测，消息重发、黑白名单）以及可扩展性的考虑等等，这些都是很复杂，那里搞不好就容易出错，看netty 权威指南的时候 记得作者他们那个时候还没有netty，经常出现一些莫名问题需要进行解决，而很多问题netty已经帮我们解决了，所以有必要好好看看netty了（目前作者也在看netty权威指南，唯一不爽的时候，里面大量代码，习惯用工具查看代码（编辑器查看代码变色，可以跳转等），求netty权威指南代码地址，看书里面代码特别变扭！，谢谢）

简单聊几句AIO

虽然NIO在网络操作中提供了非阻塞方法，但是NIO的IO行为还是同步的，对于NIO来说，我们的业务线程是在IO操作准备好时，才得到通知，接着就有这个线程自行完成IO操作，但是IO操作的本身其实还是同步的。

AIO是异步IO的缩写，相对与NIO来说又进了一步，它不是在IO准备好时再通知线程，而是在IO操作完成后在通知线程，所以AIO是完全不阻塞的，我们的业务逻辑看起来就像一个回调函数了。