浅谈 JAVA 中关于NIO知识

一:NIO的理解

　　NIO作为同步非阻塞流与普通IO最大的区别就是 NIO针对缓冲流进行操作而传统IO基于字节、字符进行操作。 NIO主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector。NIO基于Channel和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector被用来监听多个通道的事件,可以通过SelectorKey来获取当前通道的状态:(SelectionKey.OP_CONNECT（连接就绪） 、SelectionKey.OP_ACCEPT（接受就绪）、 SelectionKey.OP_READ（读就绪）、SelectionKey.OP_WRITE（写就绪）。

　　Channel:

　　　　　　 此通道接口的主要实现类为: FileChannel 、DatagramChannel、SocketChannel、ServerSocketChannel。

　　　　　　例:FileChannel fc = new RandomAccessFile(new FIle("D\\b.text","wr")).getChannel;  SocketChannel sc = new Socket().getChannel();

　　　　Channel的非阻塞需要调用: configureBlocking(false)方法，在非阻塞式信道上调用一个方法总是会立即返回。这种调用的返回值指示了所请求的操作完成的程度。例如，在一个非阻塞式ServerSocketChannel上调用accept()方法，如果有连接请求来了，则返回客户端SocketChannel，否则返回null。

 

 

 

　　Buffer:

　　　　　　NIO中的关键Buffer实现有：ByteBuffer, CharBuffer, DoubleBuffer, FloatBuffer, IntBuffer, LongBuffer, ShortBuffer，分别对应基本数据类型: byte, char, double, float, int, long, short。

　　　　　　使用NIO读取文件的例子:                                                          

public static void method1(){
    RandomAccessFile aFile = null;
    try{
        aFile = new RandomAccessFile("src/nio.txt","rw");
        FileChannel fileChannel = aFile.getChannel();
        ByteBuffer buf = ByteBuffer.allocate(1024);
        int bytesRead = fileChannel.read(buf);
        System.out.println(bytesRead);
        while(bytesRead != -1)
        {
            buf.flip();
            while(buf.hasRemaining())
            {
                System.out.print((char)buf.get());
            }
            buf.compact();
            bytesRead = fileChannel.read(buf);
        }
    }catch (IOException e){
        e.printStackTrace();
    }finally{
        try{
            if(aFile != null){
                aFile.close();
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}
注:
　　compact()方法主要是将buffer中的position指针与limit更换位置，用来让下一次写入缓冲区的时候不对之前已存在的值进行覆盖。
　　flip()方法是将position指针指到缓冲区的头部，进而变相将一个“写”缓冲区变为“读”缓冲区

        　　　　

 

 

 

 

 

 

　　Selector:

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

　　　　　　Selector类可以用于避免使用阻塞式客户端中很浪费资源的“忙等”方法。选择器就是一个多路开关选择器，因为一个选择器能够管理多个信道上的I/O操作。它可以在判断不同信道的状态时发挥作用，不需要通过对所有信道循环遍历查询状态。

　　　　　　如果使用Selector，它返回的结果只有两种结果，一种是0，即在你调用的时刻没有任何客户端需要I/O操作，另一种结果是一组需要I/O操作的客户端。

　　　　　　要使用选择器（Selector），需要创建一个Selector实例（使用静态工厂方法open()）并将其注册（register）到想要监控的信道上（注意，这要通过channel的方法实现，而不是使用selector的方法）。最后，调用选择器的select()方法。该方法会阻塞等待，直到有一个或更多的信道准备好了I/O操作或等待超时。select()方法将返回可进行I/O操作的信道数量。

 

　　　　　　下面举一个TCP服务端NIO写法:

　　　　　　

private static final int BUF_SIZE=1024;
private static final int PORT = 8080;
private static final int TIMEOUT = 3000;

public static void main(String[] args)
{
    selector();
}
public static void handleAccept(SelectionKey key) throws IOException{
    ServerSocketChannel ssChannel = (ServerSocketChannel)key.channel();
    SocketChannel sc = ssChannel.accept();
    sc.configureBlocking(false);
    sc.register(key.selector(), SelectionKey.OP_READ,ByteBuffer.allocateDirect(BUF_SIZE));
}


public static void handleRead(SelectionKey key) throws IOException{
    SocketChannel sc = (SocketChannel)key.channel();
    ByteBuffer buf = (ByteBuffer)key.attachment();
    long bytesRead = sc.read(buf);
    while(bytesRead>0){
        buf.flip();
        while(buf.hasRemaining()){
            System.out.print((char)buf.get());
        }
        System.out.println();
        buf.clear();
        bytesRead = sc.read(buf);
    }
    if(bytesRead == -1){
        sc.close();
    }
}


public static void handleWrite(SelectionKey key) throws IOException{
    ByteBuffer buf = (ByteBuffer)key.attachment();
    buf.flip();
    SocketChannel sc = (SocketChannel) key.channel();
    while(buf.hasRemaining()){
        sc.write(buf);
    }
    buf.compact();
}


public static void selector() {
    Selector selector = null;
    ServerSocketChannel ssc = null;
    try{
        selector = Selector.open();
        ssc= ServerSocketChannel.open();
        ssc.socket().bind(new InetSocketAddress(PORT));
        ssc.configureBlocking(false);
        ssc.register(selector, SelectionKey.OP_ACCEPT);
        while(true){
            if(selector.select(TIMEOUT) == 0){
                System.out.println("==");
                continue;
            }
            Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
            while(iter.hasNext()){
                SelectionKey key = iter.next();
                if(key.isAcceptable()){
                    handleAccept(key);
                }
                if(key.isReadable()){
                    handleRead(key);
                }
                if(key.isWritable() && key.isValid()){
                    handleWrite(key);
                }
                if(key.isConnectable()){
                    System.out.println("isConnectable = true");
                }
                iter.remove();
            }
        }
    }catch(IOException e){
        e.printStackTrace();
    }finally{
        try{
            if(selector!=null){
                selector.close();
            }
            if(ssc!=null){
                ssc.close();
            }
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

 

　

 

　　　　最后，如果还有不懂的地方推荐一个大牛的详细讲解:https://blog.csdn.net/u011381576/article/details/79876754