NIO深入浅出

背景

java.nio全称java non-blocking IO,是指jdk1.4 及以上版本里提供的新api(New IO) ,为所有的原始类型(boolean类型除外)提供缓存支持的数据容器,使用它可以提供非阻塞式的高伸缩性网络。

概述

底层原理:

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

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

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

IO模型:

多路复用IO模型

多路复用IO是在同步非阻塞IO基础上优化而来,在同步非阻塞的情况下,用户线程需要轮训的请求,来获取返回的数据,而多路复用模式这个轮训操作交给了selector(选择器),selector会一直阻塞,直到有scoket返回,而且一个selector可以监听多个IO事件。

重要成员:

1.Channel(通道)

NIO中的Channel的主要实现有:

FileChannel

DatagramChannel

SocketChannel

ServerSocketChannel

2.Buffer(缓冲区)

缓冲区,实际上是一个容器,一个连续数组。Channel提供从文件、网络读取数据的渠道,但是读写的数据都必须经过Buffer。NIO中的关键Buffer实现有:ByteBuffer, CharBuffer, DoubleBuffer, FloatBuffer, IntBuffer, LongBuffer, ShortBuffer,分别对应基本数据类型: byte, char, double, float, int, long, short。当然NIO中还有MappedByteBuffer, HeapByteBuffer, DirectByteBuffer等。这里介绍一下MappedByteBuffer,MappedByteBuffer是NIO引入的文件内存映射方案,读写性能极高。NIO最主要的就是实现了对异步操作的支持。其中一种通过把一个套接字通道(SocketChannel)注册到一个选择器(Selector)中,不时调用后者的选择(select)方法就能返回满足的选择键(SelectionKey),键中包含了SOCKET事件信息。这就是select模型。

SocketChannel的读写是通过一个类叫ByteBuffer来操作的.这个类本身的设计是不错的,比直接操作byte[]方便多了. ByteBuffer有两种模式:直接/间接.间接模式最典型(也只有这么一种)的就是HeapByteBuffer,即操作堆内存 (byte[]).但是内存毕竟有限,如果我要发送一个1G的文件怎么办?不可能真的去分配1G的内存.这时就必须使用”直接”模式,即 MappedByteBuffer,文件映射.

下面我们看看NIO读取数据的模式:写数据和读数据都会先写入buffer然后再channel再从buffer读,然后channel再写入buffer,server从buffer中取


方法调用:

向Buffer中写数据:

从Channel写到Buffer (fileChannel.read(buf))

通过Buffer的put()方法 (buf.put(…))

从Buffer中读取数据:

从Buffer读取到Channel (channel.write(buf))

使用get()方法从Buffer中读取数据 (buf.get())

Buffer数组结构:

capacity数组长度,position下一个需要处理的数据下标,limit数组中不可操作的下一个数据的位置,mark用于记录当前position的位置

3.Selector

Selector运行单线程处理多个Channel,如果你的应用打开了多个通道,但每个连接的流量都很低,使用Selector就会很方便

方法调用:

Selector的创建:

Selector selector = Selector.open();

selector .socket().bind(new InetSocketAddress(PORT));

 selector .configureBlocking(false);

 selector .register(selector, SelectionKey.OP_ACCEPT);

注意register()方法的第二个参数。这是一个“interest集合”,意思是在通过Selector监听Channel时对什么事件感兴趣。可以监听四种不同类型的事件,这四种事件用SelectionKey的四个常量来表示:

SelectionKey.OP_CONNECT

SelectionKey.OP_ACCEPT

SelectionKey.OP_READ

SelectionKey.OP_WRITE

可以用像检测interest集合那样的方法,来检测channel中什么事件或操作已经就绪。但是,也可以使用以下四个方法,它们都会返回一个布尔类型:

selectionKey.isAcceptable();

selectionKey.isConnectable();

selectionKey.isReadable();

selectionKey.isWritable();

从SelectionKey访问Channel和Selector很简单。如下:

Channel  channel  = selectionKey.channel();

Selector selector = selectionKey.selector();

下面是select()方法:

int select()

int select(long timeout)

int selectNow()

select()阻塞到至少有一个通道在你注册的事件上就绪了。

select(long timeout)和select()一样,除了最长会阻塞timeout毫秒(参数)。

selectNow()不会阻塞,不管什么通道就绪都立刻返回(译者注:此方法执行非阻塞的选择操作。如果自从前一次选择操作后,没有通道变成可选择的,则此方法直接返回零。)。

select()方法返回的int值表示有多少通道已经就绪。亦即,自上次调用select()方法后有多少通道变成就绪状态。如果调用select()方法,因为有一个通道变成就绪状态,返回了1,若再次调用select()方法,如果另一个通道就绪了,它会再次返回1。如果对第一个就绪的channel没有做任何操作,现在就有两个就绪的通道,但在每次select()方法调用之间,只有一个通道就绪了。

一旦调用了select()方法,并且返回值表明有一个或更多个通道就绪了,然后可以通过调用selector的selectedKeys()方法,访问“已选择键集(selected key set)”中的就绪通道。如下所示:

Set selectedKeys = selector.selectedKeys();

当像Selector注册Channel时,Channel.register()方法会返回一个SelectionKey 对象。这个对象代表了注册到该Selector的通道。可以通过SelectionKey的selectedKeySet()方法访问这些对象。

注意每次迭代末尾的keyIterator.remove()调用。Selector不会自己从已选择键集中移除SelectionKey实例。必须在处理完通道时自己移除。下次该通道变成就绪时,Selector会再次将其放入已选择键集中。

SelectionKey.channel()方法返回的通道需要转型成你要处理的类型,如ServerSocketChannel或SocketChannel等。

最后上代码:

import java.io.IOException;

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; 


/**

* NIO服务端

*/ 

public class NIOServer { 

    //通道管理器 

    private Selector selector; 

    /**

    * 获得一个ServerSocket通道,并对该通道做一些初始化的工作

    * @param port  绑定的端口号

    * @throws IOException

    */ 

    public void initServer(int port) throws IOException { 

        // 获得一个ServerSocket通道 

        ServerSocketChannel serverChannel = ServerSocketChannel.open(); 

        // 设置通道为非阻塞 

        serverChannel.configureBlocking(false); 

        // 将该通道对应的ServerSocket绑定到port端口 

        serverChannel.socket().bind(new InetSocketAddress(port)); 

        // 获得一个通道管理器 

        this.selector = Selector.open(); 

        //将通道管理器和该通道绑定,并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后, 

        //当该事件到达时,selector.select()会返回,如果该事件没到达selector.select()会一直阻塞。 

        serverChannel.register(selector, SelectionKey.OP_ACCEPT); 

    } 


    /**

    * 采用轮询的方式监听selector上是否有需要处理的事件,如果有,则进行处理

    * @throws IOException

    */ 

    @SuppressWarnings("unchecked") 

    public void listen() throws IOException { 

        System.out.println("服务端启动成功!"); 

        // 轮询访问selector 

        while (true) { 

            //当注册的事件到达时,方法返回;否则,该方法会一直阻塞 

            selector.select(); 

            // 获得selector中选中的项的迭代器,选中的项为注册的事件 

            Iterator ite = this.selector.selectedKeys().iterator(); 

            while (ite.hasNext()) { 

                SelectionKey key = (SelectionKey) ite.next(); 

                // 删除已选的key,以防重复处理 

                ite.remove(); 

                // 客户端请求连接事件 

                if (key.isAcceptable()) { 

                    ServerSocketChannel server = (ServerSocketChannel) key 

                            .channel(); 

                    // 获得和客户端连接的通道 

                    SocketChannel channel = server.accept(); 

                    // 设置成非阻塞 

                    channel.configureBlocking(false); 


                    //在这里可以给客户端发送信息哦

                    channel.write(ByteBuffer.wrap(new String("向客户端发送了一条信息").getBytes())); 

                    //在和客户端连接成功之后,为了可以接收到客户端的信息,需要给通道设置读的权限。 

                    channel.register(this.selector, SelectionKey.OP_READ); 


                    // 获得了可读的事件 

                } else if (key.isReadable()) { 

                        read(key); 

                } 


            } 


        } 

    } 

    /**

    * 处理读取客户端发来的信息 的事件

    * @param key

    * @throws IOException 

    */ 

    public void read(SelectionKey key) throws IOException{ 

        // 服务器可读取消息:得到事件发生的Socket通道 

        SocketChannel channel = (SocketChannel) key.channel(); 

        // 创建读取的缓冲区 

        ByteBuffer buffer = ByteBuffer.allocate(10); 

        channel.read(buffer); 

        byte[] data = buffer.array(); 

        String msg = new String(data).trim(); 

        System.out.println("服务端收到信息:"+msg); 

        ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes()); 

        channel.write(outBuffer);// 将消息回送给客户端 

    } 


    /**

    * 启动服务端测试

    * @throws IOException 

    */ 

    public static void main(String[] args) throws IOException { 

        NIOServer server = new NIOServer(); 

        server.initServer(8000); 

        server.listen(); 

    } 


/**

* NIO客户端

*/ 

public class NIOClient { 

    //通道管理器 

    private Selector selector; 


    /**

    * 获得一个Socket通道,并对该通道做一些初始化的工作

    * @param ip 连接的服务器的ip

    * @param port  连接的服务器的端口号         

    * @throws IOException

    */ 

    public void initClient(String ip,int port) throws IOException { 

        // 获得一个Socket通道 

        SocketChannel channel = SocketChannel.open(); 

        // 设置通道为非阻塞 

        channel.configureBlocking(false); 

        // 获得一个通道管理器 

        this.selector = Selector.open(); 


        // 客户端连接服务器,其实方法执行并没有实现连接,需要在listen()方法中调 

        //用channel.finishConnect();才能完成连接 

        channel.connect(new InetSocketAddress(ip,port)); 

        //将通道管理器和该通道绑定,并为该通道注册SelectionKey.OP_CONNECT事件。 

        channel.register(selector, SelectionKey.OP_CONNECT); 

    } 


    /**

    * 采用轮询的方式监听selector上是否有需要处理的事件,如果有,则进行处理

    * @throws IOException

    */ 

    @SuppressWarnings("unchecked") 

    public void listen() throws IOException { 

        // 轮询访问selector 

        while (true) { 

            selector.select(); 

            // 获得selector中选中的项的迭代器 

            Iterator ite = this.selector.selectedKeys().iterator(); 

            while (ite.hasNext()) { 

                SelectionKey key = (SelectionKey) ite.next(); 

                // 删除已选的key,以防重复处理 

                ite.remove(); 

                // 连接事件发生 

                if (key.isConnectable()) { 

                    SocketChannel channel = (SocketChannel) key 

                            .channel(); 

                    // 如果正在连接,则完成连接 

                    if(channel.isConnectionPending()){ 

                        channel.finishConnect(); 


                    } 

                    // 设置成非阻塞 

                    channel.configureBlocking(false); 


                    //在这里可以给服务端发送信息哦 

                    channel.write(ByteBuffer.wrap(new String("向服务端发送了一条信息").getBytes())); 

                    //在和服务端连接成功之后,为了可以接收到服务端的信息,需要给通道设置读的权限。 

                    channel.register(this.selector, SelectionKey.OP_READ); 


                    // 获得了可读的事件 

                } else if (key.isReadable()) { 

                        read(key); 

                } 


            } 


        } 

    } 

    /**

    * 处理读取服务端发来的信息 的事件

    * @param key

    * @throws IOException 

    */ 

    public void read(SelectionKey key) throws IOException{ 

        //和服务端的read方法一样 

    } 



    /**

    * 启动客户端测试

    * @throws IOException 

    */ 

    public static void main(String[] args) throws IOException { 

        NIOClient client = new NIOClient(); 

        client.initClient("localhost",8000); 

        client.listen(); 

    } 

推荐阅读更多精彩内容