• Java的NIO


    Java NIO(New IO)是从Java 1.4版本开始引入的一个新的IO API,可以替代标准的Java IO API。

    一、 Java NIO和IO的主要区别

    下表总结了Java NIO和IO之间的主要差别,我会更详细地描述表中每部分的差异。

    IONIO
    Stream oriented Buffer oriented
    Blocking IO Non blocking IO
      Selectors

    1、 面向流与面向缓冲

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

    2、 阻塞与非阻塞IO

    Java IO的各种流是阻塞的。这意味着,当一个线程调用read() 或 write()时,该线程被阻塞,直到有一些数据被读取,或数据完全写入。该线程在此期间不能再干任何事情了。 Java NIO的非阻塞模式,使一个线程从某通道发送请求读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取。而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作,所以一个单独的线程现在可以管理多个输入和输出通道(channel)。

    3、 选择器

    Java NIO的选择器允许一个单独的线程来监视多个输入通道,你可以注册多个通道使用一个选择器,然后使用一个单独的线程来“选择”通道:这些通道里已经有可以处理的输入,或者选择已准备写入的通道。这种选择机制,使得一个单独的线程很容易来管理多个通道。

    4、使用场景

    NIO可让您只使用一个(或几个)单线程管理多个通道(网络连接或文件),但付出的代价是解析数据可能会比从一个阻塞流中读取数据更复杂。

    NIO

    如果需要管理同时打开的成千上万个连接,这些连接每次只是发送少量的数据,例如聊天服务器,实现NIO的服务器可能是一个优势。同样,如果你需要维持许多打开的连接到其他计算机上,如P2P网络中,使用一个单独的线程来管理你所有出站连接,可能是一个优势。一个线程多个连接的设计方案如下图所示:

    IO

    如果你有少量的连接使用非常高的带宽,一次发送大量的数据,也许典型的IO服务器实现可能非常契合。下图说明了一个典型的IO服务器设计:

     


    二、NIO的使用

    Java NIO 由以下几个核心部分组成:

    • Channels
    • Buffers
    • Selectors

    NIO的调用过程如下图所示:

     

    1、Buffer(缓冲区)

    1.1 Buffer状态

    Buffer缓冲区本质上是一块可以写入数据,然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象,并提供了一组方法,用来方便的访问该模块内存。为了理解Buffer的工作原理,需要熟悉它的三个属性:capacity、position和limit。
    • capacity:作为一个内存块,Buffer有固定的大小值,也叫作“capacity”,只能往其中写入capacity个byte、long、char等类型。一旦Buffer满了,需要将其清空(通过读数据或者清楚数据)才能继续写数据。
    • position:当你写数据到Buffer中时,position表示当前的位置。出事的position值为0,当写入一个字节数据到Buffer中后,position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity-1。当读取数据时,也是从某个特定位置读,讲Buffer从写模式切换到读模式,position会被重置为0。当从Buffer的position处读取一个字节数据后,position向前移动到下一个可读的位置。
    • limit:在写模式下,Buffer的limit表示你最多能往Buffer里写多少数据。 写模式下,limit等于Buffer的capacity。当切换Buffer到读模式时, limit表示你最多能读到多少数据。因此,当切换Buffer到读模式时,limit会被设置成写模式下的position值。换句话说,你能读到之前写入的所有数据(limit被设置成已写数据的数量,这个值在写模式下就是position) 

    1.2 Buffer支持的数据类型

    Java NIO 有以下Buffer类型:

    • ByteBuffer
    • MappedByteBuffer
    • CharBuffer
    • DoubleBuffer
    • FloatBuffer
    • IntBuffer
    • LongBuffer
    • ShortBuffer

    如你所见,这些Buffer类型代表了不同的数据类型。换句话说,就是可以通过char,short,int,long,float 或 double类型来操作缓冲区中的字节。

    1.3 Buffer的分配

    要想获得一个Buffer对象首先要进行分配。 每一个Buffer类都有一个allocate方法。下面是一个分配48字节capacity的ByteBuffer的例子。

    ByteBuffer buf = ByteBuffer.allocate(48); 

    分配一个可存储1024个字符的CharBuffer:

    CharBuffer buf = CharBuffer.allocate(1024); 

     1.4 向Buffer中写数据

    int bytesRead = inChannel.read(buf); //read into buffer. 

     使用put方法:

    buf.put(127);

     put方法有很多版本,允许你以不同的方式把数据写入到Buffer中。

    1.5 flip()方法切换模式

    flip()方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0,并将limit设置成之前position的值。

    换句话说,position现在用于标记读的位置,limit表示之前写进了多少个byte、char等 —— 现在能读取多少个byte、char等。

    1.6 从Buffer中读取数据

    使用read从Buffer读取数据到Channel的例子:
    int bytesWritten = inChannel.write(buf);

    或者使用get()方法

    byte aByte = buf.get();

    get方法有很多版本,允许你以不同的方式从Buffer中读取数据。

    1.7 清空buffer

    一旦读完Buffer中的数据,需要让Buffer准备好再次被写入。可以通过clear()或compact()方法来完成。

    如果调用的是clear()方法,position将被设回0,limit被设置成 capacity的值。换句话说,Buffer 被清空了。Buffer中的数据并未清除,只是这些标记告诉我们可以从哪里开始往Buffer里写数据。

    如果Buffer中有一些未读的数据,调用clear()方法,数据将“被遗忘”,意味着不再有任何标记会告诉你哪些数据被读过,哪些还没有。

    clear()用于将Buffer从读模式切换成写模式。

    如果Buffer中仍有未读的数据,且后续还需要这些数据,但是此时想要先先写些数据,那么使用compact()方法。

    compact()方法将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素正后面。limit属性依然像clear()方法一样,设置成capacity。现在Buffer准备好写数据了,但是不会覆盖未读的数据。

    2、Channel的实现

    Java NIO的通道类似流,但又有些不同:

    • 既可以从通道中读取数据,又可以写数据到通道。但流的读写通常是单向的。
    • 通道可以异步地读写。
    • 通道中的数据总是要先读到一个Buffer,或者总是要从一个Buffer中写入。

    正如上面所说,从通道读取数据到缓冲区,从缓冲区写入数据到通道。

    Java NIO中最通道的分类:

    • FileChannel:从文件中读写数据
    • DatagramChannel:能通过UDP读写网络中的数据
    • SocketChannel:能通过TCP读写网络中的数据
    • ServerSocketChannel:可以监听新进来的TCP连接,像Web服务器那样。对每一个新进来的连接都会创建一个SocketChannel

    3、完整的Channel+Buffer示例

    public class NioTestDemo {
    
        public static void main(String[] args) {
            try{
                //将文件打开为流模式
                FileInputStream fileInputStream = new FileInputStream(new File("D://a.txt"));
                //打开源文件流管道
                FileChannel readChannel = fileInputStream.getChannel();
                //定义缓冲区
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                //对流出的地址文件打开流模式
                FileOutputStream fileOutputStream = new FileOutputStream(new File("E://a.txt"));
                //打开目的地文件流管道
                FileChannel writeChannel = fileOutputStream.getChannel();
    
                //开始读取
                while (true) {
                    //清除缓存区文件,保证缓冲区的干净
                    buffer.clear();
                    //源文件数据流入管道,到缓冲区
                    int len = readChannel.read(buffer);
                    if (len == -1 ) {
                        break;
                    }
                    //位置倒置:下一篇文章重点对BufferAPI介绍
                    buffer.flip();
                    //写入文件
                    writeChannel.write(buffer);
                }
                //关闭管道
                readChannel.close();
                writeChannel.close();
    
            }catch (Exception e){
    
            }
        }
    
    }

     4、选择器(Selector)

     Selector(选择器)是Java NIO中能够检测一到多个NIO通道,并能够知晓通道是否为诸如读写事件做好准备的组件。这样,一个单独的线程可以管理多个channel,从而管理多个网络连接。假如一个应用打开了多个连接(通道),但每个连接的流量都很低,使用Selector就会很方便。例如,在一个聊天服务器中。

    仅用单个线程来处理多个Channels的好处是,只需要更少的线程来处理通道。事实上,可以只用一个线程处理所有的通道。对于操作系统来说,线程之间上下文切换的开销很大,而且每个线程都要占用系统的一些资源(如内存)。因此,使用的线程越少越好。
    要使用Selector,得向Selector注册Channel,然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回,线程就可以处理这些事件,事件的例子有如新连接进来,数据接收等。
     

    通过Selector监听Channel时对什么事件感兴趣。可以监听四种不同类型的事件:

    • Connect
    • Accept
    • Read
    • Write
    Selector selector = Selector.open();  
    channel.configureBlocking(false);  
    SelectionKey key = channel.register(selector, SelectionKey.OP_READ);  
    while(true) {  
      int readyChannels = selector.select();  
      if(readyChannels == 0) continue;  
      Set selectedKeys = selector.selectedKeys();  
      Iterator 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();  
      }  
    } 
    一个基于selector和socketchannel的例子:
     
    参考文章:
    链接:https://www.jianshu.com/p/919a7555991a
    链接:https://www.jianshu.com/p/5bb812ca5f8e
  • 相关阅读:
    ESP8266 SDK开发
    硬件基础知识和典型应用-Altium Designer 加载SETP文件设置3D封装
    Golang 协程控制关闭
    Redis主从集群切换数据丢失问题
    Goroutine(协程)的理解
    堆和栈的概念和区别
    golang goroutine实现_golang中的Mutex设计原理详解(一)
    OpenCV cv::Mat.type() 以及各类型数据转换
    python 处理json
    python 文件|路径 常用方法
  • 原文地址:https://www.cnblogs.com/david1216/p/13387453.html
Copyright © 2020-2023  润新知