NIO机制初探

最新推荐文章于 2024-07-12 14:26:59 发布

ndzj981479673

最新推荐文章于 2024-07-12 14:26:59 发布

阅读量677

点赞数

分类专栏： NIO 文章标签： nio buffer select

本文链接：https://blog.csdn.net/nju08cs/article/details/38456477

版权

NIO 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

nio是java1.4的新特性，主要是为了解决读写文件和读写网络资源时，阻塞读和阻塞写的问题。

bio每次读和写的时候都会阻塞，直到读/写的数据全部完成为止。

在网络连接serverSocket中，accept总是阻塞，知道有客户端请求来，然后创建一个单独的线程来处理用户请求，这就带来一个性能瓶颈。

为解决这个问题，java引入nio，其实是仿照linux里面的select函数，通过事件注册和事件响应，实现异步的读写。

阻塞I/O

在调用InputStream.read()方法时是阻塞的，它会一直等到数据到来时（或超时）才会返回；同样，在调用ServerSocket.accept()方法时，也会一直阻塞到有客户端连接才会返回。阻塞的时候，cpu会执行其它任务，从而可能会导致一次上下文切换。1. 当客户端多时，会创建大量的处理线程。且每个线程都要占用栈空间和一些CPU时间。2. 阻塞可能带来频繁的上下文切换，且大部分上下文切换可能是无意义的。

非阻塞：

1. 由一个专门的线程来处理所有的 IO 事件，并负责分发。

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

3. 线程通讯：线程之间通过 wait,notify 等方式通讯。保证每次上下文切换都是有意义的。减少无谓的线程切换。

举个栗子：

在阻塞式里面，每个线程需要不断的轮询，上下文切换，以达到找到目的地的结果。而在非阻塞方式里，每个线程都在休眠，只在真正外部环境准备好了才唤醒，这样的唤醒肯定不会阻塞。使得每一次的上下文切换都是有意义的。

java NIO的服务端只需启动一个专门的线程来处理所有的 IO 事件，这种通信模型是怎么实现的呢？java NIO采用了双向通道（channel）进行数据传输，而不是单向的流（stream），在通道上可以注册我们感兴趣的事件。一共有以下四种事件：

服务端接收客户端连接事件	SelectionKey.OP_ACCEPT(16)
客户端连接服务端事件	SelectionKey.OP_CONNECT(8)
读事件	SelectionKey.OP_READ(1)
写事件	SelectionKey.OP_WRITE(4)

服务端和客户端各自维护一个管理通道的对象，我们称之为selector，该对象能检测一个或多个通道 (channel) 上的事件。我们以服务端为例，如果服务端的selector上注册了读事件，某时刻客户端给服务端发送了一些数据，阻塞I/O这时会调用read()方法阻塞地读取数据，而NIO的服务端会在selector中添加一个读事件。服务端的处理线程会轮询地访问selector，如果访问selector时发现有感兴趣的事件到达，则处理这些事件，如果没有感兴趣的事件到达，则处理线程会一直阻塞直到感兴趣的事件到达为止。

服务端处理线程：

while(true){

selector.select(); ------------—阻塞等待事件———————> Selector <--------注册事件--------------

处理时间

}

Selector是异步 IO 的核心类，它能检测一个或多个通道 (channel) 上的事件，并将事件分发出去。

使用一个 select 线程就能监听多个通道上的事件，并基于事件驱动触发相应的响应。而不需要为每个 channel 去分配一个线程。

Selector允许单线程处理多个 Channel。如果你的应用打开了多个连接（通道），但每个连接的流量都很低，使用Selector就会很方便。例如，在一个聊天服务器中。这是在一个单线程中使用一个Selector处理3个Channel。要使用Selector，得向Selector注册Channel，然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就可以处理这些事件，事件的例子有如新连接进来，数据接收等。与Selector一起使用时，Channel必须处于非阻塞模式下。这意味着不能将FileChannel与Selector一起使用，因为FileChannel不能切换到非阻塞模式。而套接字通道都可以。

1 Selector的创建

通过调用Selector.open()方法创建一个Selector，如下：

`1`	`Selector selector = Selector.open();`

2 向Selector注册通道

为了将Channel和Selector配合使用，必须将channel注册到selector上。通过SelectableChannel.register()方法来实现，如下：

 
   1channel.configureBlocking(false);
 
   2SelectionKey key = channel.register(selector,Selectionkey.OP_READ);Selectionkey.OP_READ);
 
 3 通过Selector选择通道 一旦向Selector注册了一或多个通道，就可以调用几个重载的select()方法。这些方法返回你所感兴趣的事件（如连接、接受、读或写）已经准备就绪的那些通道。换句话说，如果你对“读就绪”的通道感兴趣，select()方法会返回读事件已经就绪的那些通道。
 下面是select()方法：
int select()
int select(long timeout)
int selectNow()该方法不阻塞，直接返回
 4 selectedKeys() 一旦调用了select()方法，并且返回值表明有一个或更多个通道就绪了，然后可以通过调用selector的selectedKeys()方法，访问“已选择键集（selected key set）”中的就绪通道。如下所示：
 
       1Set selectedKeys = selector.selectedKeys();
 
 当像Selector注册Channel时，Channel.register()方法会返回一个SelectionKey 对象。这个对象代表了注册到该Selector的通道。可以通过SelectionKey的selectedKeySet()方法访问这些对象。
 可以遍历这个已选择的键集合来访问就绪的通道。

 5 wakeUp() 某个线程调用select()方法后阻塞了，即使没有通道已经就绪，也有办法让其从select()方法返回。只要让其它线程在第一个线程调用 select()方法的那个对象上调用Selector.wakeup()方法即可。阻塞在select()方法上的线程会立马返回。
 如果有其它线程调用了wakeup()方法，但当前没有线程阻塞在select()方法上，下个调用select()方法的线程会立即“醒来（wake up）”。
 
 6 close() 用完Selector后调用其close()方法会关闭该Selector，且使注册到该Selector上的所有SelectionKey实例无效。通道本身并不会关闭。

下面是使用nio创建tcp连接的服务器的demo0

	Selector selector = Selector.<strong>open</strong>();
	channel.configureBlocking(false);
	SelectionKey key = channel.<strong>register</strong>(selector, SelectionKey.OP_READ);
	while(true) {
	  intreadyChannels = selector.<strong>select</strong>();
	  if(readyChannels ==0) continue;
	  Set selectedKeys = selector.selectedKeys();
	  Iterator keyIterator = selectedKeys.iterator();
	  while(keyIterator.hasNext()) {
	    SelectionKey key = keyIterator.next();
	    if(key.<strong>isAcceptable</strong>()) {
	        // a connection was accepted by a ServerSocketChannel.
	    } else if (key.<strong>isConnectable</strong>()) {
	        // a connection was established with a remote server.
	    } else if (key.<strong>isReadable</strong>()) {
	        // a channel is ready for reading
	    } else if (key.<strong>isWritable</strong>()) {
	        // a channel is ready for writing
	    }
	    keyIterator.remove();
	  }
	}

SocketChannel

1打开 SocketChannel

下面是SocketChannel的打开方式：

`1`	`SocketChannel socketChannel = SocketChannel.open();`

`2`	`socketChannel.connect(new` `InetSocketAddress("http://jenkov.com",` `80));`

2关闭 SocketChannel

当用完SocketChannel之后调用SocketChannel.close()关闭SocketChannel：

`1`	`socketChannel.close();`

3从 SocketChannel 读取数据

要从SocketChannel中读取数据，调用一个read()的方法之一。以下是例子：

 
   1ByteBuffer buf = ByteBuffer.allocate(48);
 
   2int bytesRead = socketChannel.read(buf);

首先，分配一个Buffer。从SocketChannel读取到的数据将会放到这个Buffer中。

然后，调用SocketChannel.read()。该方法将数据从SocketChannel 读到Buffer中。read()方法返回的int值表示读了多少字节进Buffer里。如果返回的是-1，表示已经读到了流的末尾（连接关闭了）。

4写入 SocketChannel

写数据到SocketChannel用的是SocketChannel.write()方法，该方法以一个Buffer作为参数。示例如下：

 
   01String newData = "New String to write to file..." + System.currentTimeMillis();
 
   03ByteBuffer buf = ByteBuffer.allocate(48);
 
   04buf.clear();
 
   05buf.put(newData.getBytes());
 
   07buf.flip();
 
   09while(buf.hasRemaining()) {
 
   10    channel.write(buf);
 
   11}

注意SocketChannel.write()方法的调用是在一个while循环中的。Write()方法无法保证能写多少字节到SocketChannel。所以，我们重复调用write()直到Buffer没有要写的字节为止

5 非阻塞模式

可以设置 SocketChannel 为非阻塞模式（non-blocking mode）.设置之后，就可以在异步模式下调用connect(), read() 和write()了。

6connect()

如果SocketChannel在非阻塞模式下，此时调用connect()，该方法可能在连接建立之前就返回了。为了确定连接是否建立，可以调用finishConnect()的方法。像这样：

 
   1socketChannel.configureBlocking(false);
 
   2socketChannel.connect(new InetSocketAddress("http://jenkov.com", 80));
 
   3 
 
   4while(! socketChannel.finishConnect() ){
 
   5    //wait, or do something else...
 
   6}

7write()

非阻塞模式下，write()方法在尚未写出任何内容时可能就返回了。所以需要在循环中调用write()。前面已经有例子了，这里就不赘述了。

8read()

非阻塞模式下,read()方法在尚未读取到任何数据时可能就返回了。所以需要关注它的int返回值，它会告诉你读取了多少字节。

ServerSocketChannel

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

`03`	`serverSocketChannel.socket().bind(new` `InetSocketAddress(9999));`

`05`	`while(true){`

`06`	`SocketChannel socketChannel = serverSocketChannel.accept();`

`09`	`//do something with socketChannel...`

10 }

part1 Sun 官方标榜的特性如下：

– 为所有的原始类型提供 (Buffer) 缓存支持。

– 字符集编码解码解决方案。

– Channel ：一个新的原始 I/O 抽象。

– 支持锁和内存映射文件的文件访问接口。

– 提供多路 (non-bloking) 非阻塞式的高伸缩性网络 I/O 。

Channel 和 buffer 是 NIO 是两个最基本的数据类型抽象。

Buffer:

– 是一块连续的内存块。

– 是 NIO 数据读或写的中转地。

Channel:

– 数据的源头或者数据的目的地

– 用于向 buffer 提供数据或者读取 buffer 数据 ,buffer 对象的唯一接口。

– 异步 I/O 支持

所有的 IO 在NIO 中都从一个Channel 开始。Channel 有点象流。数据可以从Channel读到Buffer中，也可以从Buffer 写到Channel中。

FileChannel
DatagramChannel是UDP协议使用
SocketChannel是TCP协议使用
ServerSocketChannel监听新进来的TCP连接，对每一个新进来的连接都会创建一个SocketChannel。

Java NIO中的Buffer用于和NIO通道进行交互。如你所知，数据是从通道读入缓冲区，从缓冲区写入到通道中的。

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

使用Buffer读写数据一般遵循以下四个步骤：

写入数据到Buffer
调用flip()方法
从Buffer中读取数据
调用clear()方法或者compact()方法

当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将Buffer从写模式切换到读模式。在读模式下，可以读取之前写入到buffer的所有数据。一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用clear()或compact()方法。 clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

ByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer
Mappedyteuffer，用于表示内存映射文件

下面是nio读写文件的demo1

        FileInputStream fin = new FileInputStream(infile);  
        FileOutputStream fout = new FileOutputStream(outfile);  
        // 获取输入输出通道  
        FileChannel fcin = <span style="color:#ff0000;">fin.getChannel()</span>;  
        FileChannel fcout = fout.getChannel();  
        // 创建缓冲区  
        <span style="color:#ff6666;">ByteBuffer</span> buffer = ByteBuffer.allocate(1024);  
        while (true) {  
            // clear方法重设缓冲区，使它可以接受读入的数据  
            buffer.clear();  
            // 从输入通道中将数据读到缓冲区  
            int r = <span style="color:#ff0000;">fcin.read(buffer)</span>;  
            // read方法返回读取的字节数，可能为零，如果该通道已到达流的末尾，则返回-1  
            if (r == -1) {  
                break;  
            }  
            // flip方法让缓冲区可以将新读入的数据写入另一个通道  
            buffer.flip();  
            // 从输出通道中将数据写入缓冲区  
            <span style="color:#ff0000;">fcout.write(buffer); </span> 
        }  
    }

下面是nio读取网络数据的demo2

    private Charset charset = Charset.forName("GBK");// 创建GBK字符集  
    private SocketChannel channel;  
    public void readHTMLContent() {  
        try {  
            InetSocketAddress socketAddress = new InetSocketAddress(  "www.baidu.com", 80);  
<span style="white-space:pre">	</span>//step1:打开连接  
            channel = SocketChannel.open(socketAddress);  
        //step2:发送请求，使用GBK编码  
            channel.write(charset.encode("GET " + "/ HTTP/1.1" + "\r\n\r\n"));  
            //step3:读取数据  
            ByteBuffer buffer = ByteBuffer.allocate(1024);// 创建1024字节的缓冲  
            while (channel.read(buffer) != -1) {  
                buffer.flip();// flip方法在读缓冲区字节操作之前调用。  
                System.out.println(charset.decode(buffer));  
                // 使用Charset.decode方法将字节转换为字符串  
                buffer.clear();// 清空缓冲  
            }  
        } catch (IOException e) {  
            System.err.println(e.toString());  
        } finally {  
            if (channel != null) {  
                try {  
                    channel.close();  
                } catch (IOException e) {  
                }  
            }  
        }

参考网页：

点击打开链接

selector