java NIO详解

于 2019-08-12 19:30:39 发布
阅读量214 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： nio编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/TreeShu321/article/details/99215957

文章目录


在介绍NIO编程之前，我们首先澄清一个概念：NIO到底是什么的简称？有人称之为NewI/O，这是官方叫法。之前老的I/O类库是阻塞I/O，NewI/O的目标就是让Java支持非阻塞I/O

一、NIO类库简介

新的输入/输出(NIO)库是JDK1.4中引入的。NIO弥补了原来同步阻塞I/O的不足，它在标准java代码中提供了高速的、面向块的I/O。下面对NIO的一些概念和功能做下简单的介绍。

二、缓冲区Buffer

1、 Buffer是一个对象，它包含一些要写入或要读取的数据。在面向流的I/O中，可以将数据直接写入或者将数据直接读到Stream对象种。
2、在NIO库中，所有的数据都是用缓冲区做处理。缓冲区实质是一个数组。通常是一个字节数组(ByteBuffer)，也可以是其他类数组。缓冲区提供了对数据的结构化访问以及维护读写位置(Limit)等信息。
使用 Buffer 读写数据一般遵循以下四个步骤：
1.写入数据到 Buffer；
2.调用 flip() 方法；
3.从 Buffer 中读取数据；
4.调用 clear() 方法或者 compact() 方法。

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

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

三、通道channel

channel是一个通道，它就像一个自来水管，网络数据通过channel读取和写入。通道与流的不同之处在于通道是双向的，流只是在一个方向上移动。而通道可以用于读、写或者二者同时进行。

正如上面提到的，所有数据都通过Buffer对象处理，所以，您永远不会将字节直接写入到Channel中，相反，您是将数据写入到Buffer中；同样，您也不会从Channel中读取字节，而是将数据从Channel读入Buffer，再从Buffer获取这个字节。
Java NIO中的Channel主要有如下几种类型：

  • FileChannel：从文件读取数据的
  • DatagramChannel：读写UDP网络协议数据
  • SocketChannel：读写TCP网络协议数据
  • ServerSocketChannel：可以监听TCP连接

四、 Selector（多路复用器选择器对象）

1、多路复用器提供选择已经就绪的任务能力。简单的讲就是，Selector 会不断的轮询注册在其上的Channel，如果某个channel上面发生读或者写事件，这个channel就处于就绪状态，会被selector轮询出来，然后通过SelectionKey可以获取channel集合，进行后续I/O操作。
2、由于JDK使用了epoll()代替了传统select实现，所以它并没有最大连接句柄1024/2048的限制。这意味着只需要一个线程负责Selector的轮询。就可以接入成千上万的客户端。
3、创建Selector

Selector selector = Selector.open();

4、注册Channel到Selector
为了能让Channel和Selector配合使用，我们需要把Channel注册到Selector上。通过调用 channel.register（）方法来实现注册：

channel.configureBlocking(false);
SelectionKey key =channel.register(selector,SelectionKey.OP_READ);

注意，注册的Channel 必须设置成异步模式 才可以,否则异步IO就无法工作，这就意味着我们不能把一个FileChannel注册到Selector，因为FileChannel没有异步模式，但是网络编程中的SocketChannel是可以的。
5、SelectionKey

请注意对register()的调用的返回值是一个SelectionKey。 SelectionKey 代表这个通道在此 Selector 上注册。当某个 Selector 通知您某个传入事件时，它是通过提供对应于该事件的 SelectionKey 来进行的。SelectionKey 还可以用于取消通道的注册。

  • 可以用像检测interest集合那样的方法，来检测Channel中什么事件或操作已经就绪。但是，也可以使用以下四个方法，它们都会返回一个布尔类型：
selectionKey.isAcceptable();
selectionKey.isConnectable();
selectionKey.isReadable();
selectionKey.isWritable();

五、简单实例

1、Server服务器

package com.sl.server;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Date;
import java.util.Iterator;
import java.util.Set;

/**
 * @author shuliangzhao
 * @Title: MultiplexerTimeServer
 * @ProjectName design-parent
 * @Description: TODO
 * @date 2019/8/11 16:06
 */
public class MultiplexerTimeServer implements Runnable {

    private Selector selector;

    private ServerSocketChannel serverSocketChannel;
    
    private volatile boolean stop;

    public MultiplexerTimeServer(int port) {
        try {
            selector = Selector.open();
            serverSocketChannel = ServerSocketChannel.open();
            //设置为非阻塞模式
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.socket().bind(new InetSocketAddress(port),1024);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("The time server is start in port：" + port);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    public void stop() {
        this.stop = true;
    }

    public void run() {
        while (!stop) {
            try {
                selector.select(1000);
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                SelectionKey key = null;
                while (iterator.hasNext()) {
                    key = iterator.next();
                    iterator.remove();
                    try {
                        handleInput(key);
                    } catch (Exception e) {
                        if (key != null) {
                            key.cancel();
                            if (key.channel() != null) {
                                key.channel().close();
                            }
                        }
                    }
                }
            }catch (Throwable t) {
                 t.printStackTrace();
            }

        }

        //多路复用器关闭后，所有注册上面的Channel和Pipe等资源都会自动注册并关闭
        //所以不需要重复释放资源
        if (selector != null) {
            try {
                selector.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void handleInput(SelectionKey key) throws Exception {
        if (key.isValid()) {
             if (key.isAcceptable()) {
                 ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                 SocketChannel accept = channel.accept();
                 accept.configureBlocking(false);
                 accept.register(selector,SelectionKey.OP_READ);
             }
             if (key.isReadable()) {
                 SocketChannel channel = (SocketChannel) key.channel();
                 ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                 int readBytes = channel.read(readBuffer);
                 if (readBytes > 0) {
                     readBuffer.flip();
                     byte[] bytes = new byte[readBuffer.remaining()];
                     readBuffer.get(bytes);
                     String body = new String(bytes,"UTF-8");
                     System.out.println("the time server receive order : " + body);
                     String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ?
                             new Date(System.currentTimeMillis()).toString(): "BAD ORDER";
                     doWrite(channel,currentTime);
                 } else if (readBytes < 0) {
                     key.cancel();
                     channel.close();
                 } else {
                     // 读到0字节将忽略
                 }
             }
        }
    }

    private void doWrite(SocketChannel channel, String response) throws Exception {
        if (response != null && response.trim().length() > 0) {
            byte[] bytes = response.getBytes();
            ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
            writeBuffer.put(bytes);
            writeBuffer.flip();
            channel.write(writeBuffer);
        }
    }
}

2、Server main方法

package com.sl.server;

import java.io.IOException;

/**
 * @author shuliangzhao
 * @Title: TimeServer
 * @ProjectName design-parent
 * @Description: TODO
 * @date 2019/8/11 17:14
 */
public class TimeServer {
    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        int port = 8080;
        if (args != null && args.length > 0) {
            try {
                port = Integer.valueOf(args[0]);
            } catch (NumberFormatException e) {
                // 采用默认值
            }
        }
        MultiplexerTimeServer timeServer = new MultiplexerTimeServer(port);
        new Thread(timeServer, "NIO-MultiplexerTimeServer-001").start();
    }
}

3、client

package com.sl.client;

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

/**
 * @author shuliangzhao
 * @Title: TimeClientHandle
 * @ProjectName design-parent
 * @Description: TODO
 * @date 2019/8/11 16:53
 */
public class TimeClientHandle implements Runnable {

    private String host;

    private int port;

    private Selector selector;

    private SocketChannel socketChannel;

    private volatile boolean stop;

    public  TimeClientHandle(String host,int port) {
        this.host = host == null ? "127.0.0.1" : host;
        this.port = port;
        try {
          selector = Selector.open();
          socketChannel = SocketChannel.open();
          socketChannel.configureBlocking(false);
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    public void run() {
        try {
            doConnect();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
        while (!stop) {
            try {
                selector.select(1000);
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                SelectionKey key = null;
                while (iterator.hasNext()) {
                    key = iterator.next();
                    iterator.remove();
                    try {
                        handleInput(key);
                    } catch (Exception e) {
                        if (key != null) {
                            key.cancel();
                            if (key.channel() != null) {
                                key.channel().close();
                            }
                        }
                    }
                }
            }catch (Throwable t) {
                t.printStackTrace();
            }

        }
        //多路复用器关闭后，所有注册上面的Channel和Pipe等资源都会自动注册并关闭
        //所以不需要重复释放资源
        if (selector != null) {
            try {
                selector.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void handleInput(SelectionKey key) throws Exception {
        if (key.isValid()) {
            // 判断是否连接成功
            SocketChannel sc = (SocketChannel) key.channel();
            if (key.isConnectable()) {
                if (sc.finishConnect()) {
                    sc.register(selector, SelectionKey.OP_READ);
                    doWrite(sc);
                } else
                    System.exit(1);// 连接失败，进程退出
            }
            if (key.isReadable()) {
                ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                int readBytes = sc.read(readBuffer);
                if (readBytes > 0) {
                    readBuffer.flip();
                    byte[] bytes = new byte[readBuffer.remaining()];
                    readBuffer.get(bytes);
                    String body = new String(bytes, "UTF-8");
                    System.out.println("Now is : " + body);
                    this.stop = true;
                } else if (readBytes < 0) {
                    // 对端链路关闭
                    key.cancel();
                    sc.close();
                } else
                    ; // 读到0字节，忽略
            }
        }
    }

    private void doWrite(SocketChannel channel) throws Exception {
       byte[] req = "QUERY TIME ORDER".getBytes();
       ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);
       writeBuffer.put(req);
       writeBuffer.flip();
       channel.write(writeBuffer);
       if (!writeBuffer.hasRemaining()) {
           System.out.println("Send order 2 server succeed");
       }
    }

    private void doConnect() throws Exception {
        //如果直接连接成功，则注册到多路复用器上，发送请求消息，读应答
        if (socketChannel.connect(new InetSocketAddress(host,port)))    {
            socketChannel.register(selector,SelectionKey.OP_READ);
            doWrite(socketChannel);
        } else {
            socketChannel.register(selector,SelectionKey.OP_CONNECT)     ;
        }
    }
}

4、client main方法

package com.sl.client;

/**
 * @author shuliangzhao
 * @Title: TimeClient
 * @ProjectName design-parent
 * @Description: TODO
 * @date 2019/8/11 17:14
 */
public class TimeClient {

    public static void main(String[] args) {

        int port = 8080;
        if (args != null && args.length > 0) {
            try {
                port = Integer.valueOf(args[0]);
            } catch (NumberFormatException e) {
                // 采用默认值
            }
        }
        new Thread(new TimeClientHandle("127.0.0.1", port), "TimeClient-001").start();
    }
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

境里婆娑

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值