深入理解java：3. NIO 编程

zoukankan html css js c++ java

深入理解java：3. NIO 编程
I/O简介

I/O即输入输出，是计算机与外界世界的一个借口。

IO操作的实际主题是操作系统。

在Java编程中，一般使用流的方式来处理IO，所有的IO都被视作是单个字节的移动，通过stream对象一次移动一个字节。流IO负责把对象转换为字节，然后再转换为对象。

什么是NIO

NIO即New IO，这个库是在JDK1.4中才引入的。NIO主要用到的是块（缓冲），所以NIO的效率要比IO高很多。

在Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO

NIO和IO最大的区别是数据打包和传输方式。IO是以流的方式处理数据，而NIO是以块（缓冲）的方式处理数据。

面向流的IO一次一个字节的处理数据，一个输入流产生一个字节，一个输出流就消费一个字节。面向流的IO通常处理的很慢。

面向块（缓冲）的IO系统以块的形式处理数据。每一个操作都在一步中产生或消费一个数据块。按块要比按流快的多，但面向块的IO缺少了面向流IO所具有的简单性。

NIO基础

Buffer和Channel是标准NIO中的核心对象（网络NIO中还有个Selector核心对象），几乎每一个IO操作中都会用到它们。

Channel是对原IO中流的模拟，任何来源和目的数据都必须通过一个Channel对象。

一个Buffer实质上是一个容器对象，发给Channel的所有对象都必须先放到Buffer中；同样的，从Channel中读取的任何数据都要读到Buffer中。

使用 Buffer 读写数据一般遵循以下四个步骤：
1. 写入数据到 Buffer；
2. 调用 flip() 方法；
3. 从 Buffer 中读取数据；
4. 调用 clear() 方法或者 compact() 方法。
clear() 方法会清空整个缓冲区。compact() 方法只会清除已经读过的数据。

Channel是一个对象，可以通过它读取和写入数据。可以把它看做IO中的流：
1. Channel是双向的，既可以读又可以写，而流是单向的
2. Channel可以进行异步（非阻塞）的读写
3. 对Channel的读写必须通过buffer对象
在Java NIO中Channel主要有如下几种类型：
- FileChannel：从文件读取数据的
- DatagramChannel：读写UDP网络协议数据
- SocketChannel：读写TCP网络协议数据
- ServerSocketChannel：可以监听TCP连接
从文件中读取，需要如下三步：
1. 从FileInputStream获取Channel
2. 创建Buffer
3. 从Channel读取数据到Buffer
```
public static void copyFileUseNIO(String src,String dst) throws IOException{
           //声明源文件和目标文件
            FileInputStream fi=new FileInputStream(new File(src));
            FileOutputStream fo=new FileOutputStream(new File(dst));
            //获得传输通道channel
            FileChannel inChannel=fi.getChannel();
            FileChannel outChannel=fo.getChannel();
            //获得容器buffer
            ByteBuffer buffer=ByteBuffer.allocate(1024);
            while(true){
                //判断是否读完文件
                int eof =inChannel.read(buffer);
                if(eof==-1){
                    break;  
                }
                //重设一下buffer的position=0，limit=position
                buffer.flip();
                //开始写
                outChannel.write(buffer);
                //写完要重置buffer，重设position=0,limit=capacity
                buffer.clear();
            }
            inChannel.close();
            outChannel.close();
            fi.close();
            fo.close();
}     
```
控制buffer状态的三个变量
- position：跟踪已经写了多少数据或已经读了多少数据，它指向的是下一个字节来自哪个位置
- limit：代表还有多少数据可以取出或还有多少空间可以写入，它的值小于等于capacity。
- capacity：代表缓冲区的最大容量，一般新建一个缓冲区的时候，limit的值和capacity的值默认是相等的。
Selector

前面讲了Java NIO三个核心对象中的Buffer和Channel，现在重点介绍一下第三个核心对象Selector。

Selector是一个对象，它可以注册到很多个Channel上，监听各个Channel上发生的事件，并且能够根据事件情况决定Channel读写。

这样，通过一个线程管理多个Channel，就可以处理大量网络连接了。

下面这幅图展示了一个线程处理3个 Channel的情况：
```
Selector selector = Selector.open();
```
```
channel.configureBlocking(false);//异步 非阻塞模式
SelectionKey key =channel.register(selector,SelectionKey.OP_READ);//事件类型
```
需要注意register()方法的第二个参数，事件类型有四种：
1. Connect
2. Accept
3. Read
4. Write
```
某个线程调用select()方法后阻塞了，即使没有通道就绪，也有办法让其从select()方法返回。
只要让其它线程在第一个线程调用select()方法的那个对象上调用Selector.wakeup()方法即可。阻塞在select()方法上的线程会立马返回。
```
数据处理

Java IO: 从一个阻塞的流中读数据

在IO设计中，我们从InputStream或 Reader逐字节读取数据。假设你正在处理一基于行的文本数据流，例如：
```
Name: Anna
Age: 25
Email: anna@mailserver.com
Phone: 1234567890
```
该文本行的流可以这样处理：
InputStream input = … ; // get the InputStream from the client socket

1 BufferedReader reader = new BufferedReader(new InputStreamReader(input));

2

3 String nameLine = reader.readLine();

4 String ageLine = reader.readLine();

5 String emailLine = reader.readLine();

6 String phoneLine = reader.readLine();

一旦reader.readLine()方法返回，你就知道肯定文本行就已读完， readline()阻塞直到整行读完，这就是原因。你也知道此行包含名称；

同样，第二个readline()调用返回的时候，你知道这行包含年龄等。

正如你可以看到，该处理程序仅在有新数据读入时运行，并知道每步的数据是什么。一旦正在运行的线程已处理过读入的某些数据，该线程不会再回退数据（大多如此）。

Java NIO:从一个通道里读数据，直到所有的数据都读到缓冲区里.

一个NIO的实现会有所不同，下面是一个简单的例子：

1 ByteBuffer buffer = ByteBuffer.allocate(48);

2

3 int bytesRead = inChannel.read(buffer);

注意第二行，从通道读取字节到ByteBuffer。

当这个方法调用返回时，你不知道你所需的所有数据是否在缓冲区内。你所知道的是，该缓冲区包含一些字节，这使得处理有点困难。
假设第一次 read(buffer)调用后，读入缓冲区的数据只有半行，例如，“Name:An”，你能处理数据吗？显然不能，需要等待，直到整行数据读入缓存，在此之前，对数据的任何处理毫无意义。

所以，你怎么知道是否该缓冲区包含足够的数据可以处理呢？好了，你不知道。

发现的方法只能查看缓冲区中的数据。其结果是，在你知道所有数据都在缓冲区里之前，你必须检查几次缓冲区的数据。这不仅效率低下，而且可以使程序设计方案杂乱不堪。例如：

1 ByteBuffer buffer = ByteBuffer.allocate(48);

2

3 int bytesRead = inChannel.read(buffer);

4

5 while(! bufferFull(bytesRead) ) {

6

7 bytesRead = inChannel.read(buffer);

8

9 }

bufferFull()方法必须跟踪有多少数据读入缓冲区，并返回真或假，这取决于缓冲区是否已满。换句话说，如果缓冲区准备好被处理，那么表示缓冲区满了。

bufferFull()方法扫描缓冲区，但必须保持在bufferFull（）方法被调用之前状态相同。如果没有，下一个读入缓冲区的数据可能无法读到正确的位置。这是不可能的，但却是需要注意的又一问题。

如果缓冲区已满，它可以被处理。如果它不满，并且在你的实际案例中有意义，你或许能处理其中的部分数据。但是许多情况下并非如此。

用来处理数据的线程数

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

如果需要管理同时打开的成千上万个连接，这些连接每次只是发送少量的数据，例如聊天服务器，实现NIO的服务器可能是一个优势。

如果你有少量的连接使用非常高的带宽，一次发送大量的数据，也许典型的IO服务器实现可能非常契合。

基于 java实现TCP/IP+NIO 方式的网络通讯的方法

Java 提供了 SocketChannel和 ServerSocketChannel两个关键的类，

网络 IO 的操作则改为通过ByteBuffer 来实现。
服务器端Java代码

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

    System.out.println("Listening for connection on port " + DEFAULT_PORT);



    Selector selector = Selector.open();

    initServer(selector);

    //开始监听

    while (true) {

        selector.select();  //监控所有注册的 channel，当没有可用的IO 操作时会阻塞，有可用的IO 操作时往下执行



        for (Iterator<SelectionKey> itor = selector.selectedKeys().iterator(); itor.hasNext();) { //可进行 IO 操作的 channel的集合：selectedKeys

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

            itor.remove();

            try {

                if (key.isAcceptable()) {

                    ServerSocketChannel server = (ServerSocketChannel) key.channel(); //获取Accept操作的Channel

                    SocketChannel client = server.accept();   //客户端的SocketChannel

                    System.out.println("Accepted connection from " + client);

                    client.configureBlocking(false);  //客户端配置为非阻塞

                    SelectionKey clientKey = client.register(selector, SelectionKey.OP_READ);  //把客户端套接字通道注册到selector，并注明为OP_READ操作

                    ByteBuffer buffer = ByteBuffer.allocate(100);

                    clientKey.attach(buffer); ////客户端SelectionKey附上一个ByteBuffer

                } else if (key.isReadable()) {

                    SocketChannel client = (SocketChannel) key.channel();  //获取客户端的SocketChannel

                    ByteBuffer buffer = (ByteBuffer) key.attachment(); buffer .clear();

                    int n = client.read(buffer);  //将客户端套接字通道的数据读取到缓冲区

                    if (n > 0) {

                        receiveText = new String(buffer.array(),0,n);//接受到的数据



                        client.register(selector, SelectionKey.OP_WRITE);     // switch to OP_WRITE

                    }

                } else if (key.isWritable()) {

                    System.out.println("is writable...");

                    SocketChannel client = (SocketChannel) key.channel();   //获取客户端的SocketChannel

                    ByteBuffer buffer = (ByteBuffer) key.attachment();  buffer.clear();buffer.put(sendText.getBytes()); //sendText ："message from server"

                    buffer.flip(); client.write(buffer);  //输出到通道

                    if (buffer.remaining() == 0) {  // write finished, switch to OP_READ

                        client.register(selector, SelectionKey.OP_READ);



                    }

                }

            } catch (IOException e) {

                key.cancel();

                try { key.channel().close(); } catch (IOException ioe) { }

            }

        }

    }

}
1. private static void initServer(Selector selector) throws IOException,
2. ClosedChannelException {
3. ServerSocketChannel serverChannel = ServerSocketChannel.open(); //打开服务器套接字通道
4. ServerSocket ss = serverChannel.socket(); //检索与此服务器套接字通道关联的套接字
5. ss.bind(new InetSocketAddress(DEFAULT_PORT)); //进行服务的绑定
6. serverChannel.configureBlocking(false); //服务器配置为非阻塞
7. serverChannel.register(selector, SelectionKey.OP_ACCEPT); //把服务器套接字通道注册到selector，并注明为OP_ACCEPT操作
8. }
客户端代码：
```
public class NIOClient {
    /*服务器端地址*/  
    private final static InetSocketAddress SERVER_ADDRESS = new InetSocketAddress(  
            "localhost", 8888);  
  
    public static void main(String[] args) throws IOException {  
        // 打开socket通道  
        SocketChannel clientChannel = SocketChannel.open();  
        // 设置为非阻塞方式  
        clientChannel.configureBlocking(false);  
        // 打开选择器  
        Selector selector = Selector.open();  
        // 注册连接服务端socket动作  
        clientChannel.register(selector, SelectionKey.OP_CONNECT);  
        // 连接  
        clientChannel.connect(SERVER_ADDRESS);  
    
        SocketChannel socketChannel;
        Set<SelectionKey> selectionKeys;    
        while (true) {  
            selector.select();  
            selectionKeys = selector.selectedKeys();    
            for(SelectionKey selectionKey:selectionKeys){ 
                //判断是否为建立连接的事件
                if (selectionKey.isConnectable()) {  
                    System.out.println("client connect");  
                    socketChannel = (SocketChannel) selectionKey.channel(); 
                    // 判断此通道上是否正在进行连接操作。    
                    if (socketChannel.isConnectionPending()) { 
                        //完成连接的建立（TCP三次握手）
                        socketChannel.finishConnect();    
                        sendBuffer.clear();  
                        sendBuffer.put("Hello,Server".getBytes());  
                        sendBuffer.flip();  
                        socketChannel.write(sendBuffer);  
                    }  
                    socketChannel.register(selector, SelectionKey.OP_READ);  
                } else if (selectionKey.isReadable()) {  
                    socketChannel = (SocketChannel) selectionKey.channel();  
                    receiveBuffer.clear();  
                    count=socketChannel.read(receiveBuffer);  
                    if(count>0){  
                        receiveText = new String( receiveBuffer.array(),0,count);
                        socketChannel.register(selector, SelectionKey.OP_WRITE);  
                    }  
                } else if (selectionKey.isWritable()) {  
                    sendBuffer.clear();  
                    socketChannel = (SocketChannel) selectionKey.channel();  
                    sendText = "message from client--" ;  
                    sendBuffer.put(sendText.getBytes());  
                     //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位  
                    sendBuffer.flip();  
                    socketChannel.write(sendBuffer);
                    socketChannel.register(selector, SelectionKey.OP_READ);  
                }  
            }  
            selectionKeys.clear();  
        }  
    }  
}
```
上面的服务器端代码不够优雅，它将处理服务器Socket和客户连接Socket的代码搅在一起，

这两个Socket通道其实都是注册到Selecto里的，被封装在SelectionKey里面。也就是说无论服务器Socket还是客户连接Socket，都是针对SelectionKey去处理数据的。SelectionKeySelectionKeySelectionKeySelectionKey

当服务器变得复杂，使用命令模式将它们分开变显得非常必要。

首先创建一个接口来抽象对SelectionKey的数据处理：
Java代码

interface Handler {

    void execute(Selector selector, SelectionKey key);

}
再来看main函数：
Java代码

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

    System.out.println("Listening for connection on port " + DEFAULT_PORT);



    Selector selector = Selector.open();

    initServer(selector);



    while (true) {

        selector.select();



        for (Iterator<SelectionKey> itor = selector.selectedKeys().iterator(); itor.hasNext();) {

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

            itor.remove();

            Handler handler = (Handler) key.attachment(); //利用Java的多态特性，动态处理serverSocket SelectionKey 或 ClientSocket SelectionKey

            handler.execute(selector, key);

        }

    }

}



private static void initServer(Selector selector) throws IOException,

        ClosedChannelException {

    ServerSocketChannel serverChannel = ServerSocketChannel.open();

    ServerSocket ss = serverChannel.socket();

    ss.bind(new InetSocketAddress(DEFAULT_PORT));

    serverChannel.configureBlocking(false);

    SelectionKey serverKey = serverChannel.register(selector, SelectionKey.OP_ACCEPT); //serverChannel注册到selector后，生成一个serverSocket SelectionKey

    serverKey.attach(new ServerHandler()); //在serverSocket SelectionKey上附加了一个ServerHandler的对象，进行serverSocket SelectionKey的数据处理去处理

}
下面是ServerHandler的代码： 在获取serverSocket SelectionKey时需要进行的数据处理
Java代码

class ServerHandler implements Handler {

    public void execute(Selector selector, SelectionKey key) {

        ServerSocketChannel server = (ServerSocketChannel) key.channel();

        SocketChannel client = null;

        try {

            client = server.accept();

            System.out.println("Accepted connection from " + client);

        } catch (IOException e) {

            e.printStackTrace();

            return;

        }



        SelectionKey clientKey = null;

        try {

            client.configureBlocking(false);

            clientKey = client.register(selector, SelectionKey.OP_READ);

            clientKey.attach(new ClientHandler()); //在clientSocket SelectionKey上附加了一个clientHandler的对象，进行clientSocket SelectionKey的数据处理

        } catch (IOException e) {

            if (clientKey != null)

                clientKey.cancel();

            try { client.close(); } catch (IOException ioe) { }

        }

    }

}
下面是ClientHandler的代码： 在获取ClientSocket SelectionKey时需要进行的数据处理
Java代码

class ClientHandler implements Handler {

    private ByteBuffer buffer;



    public ClientHandler() {

        buffer = ByteBuffer.allocate(100);

    }



    public void execute(Selector selector, SelectionKey key) {

        try {

            if (key.isReadable()) {

                readKey(selector, key);

            } else if (key.isWritable()) {

                writeKey(selector, key);

            }

        } catch (IOException e) {

            key.cancel();

            try { key.channel().close(); } catch (IOException ioe) { }

        }

    }



    private void readKey(Selector selector, SelectionKey key) throws IOException {

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

        int n = client.read(buffer);

        if (n > 0) {

            buffer.flip();

            key.interestOps(SelectionKey.OP_WRITE);     // switch to OP_WRITE

        }

    }



    private void writeKey(Selector selector, SelectionKey key) throws IOException {

        // System.out.println("is writable...");

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

        client.write(buffer);

        if (buffer.remaining() == 0) {  // write finished, switch to OP_READ

            buffer.clear();

            key.interestOps(SelectionKey.OP_READ);

        }

    }

}
代码结构显得更清晰。
查看全文

相关阅读:
互质与欧拉函数学习笔记
 Luogu P4588 [TJOI2018]数学计算题解
 Luogu P1072 Hankson 的趣味题题解
 Luogu [POI2002][HAOI2007]反素数题解
 Luogu P2986 [USACO10MAR]伟大的奶牛聚集Great Cow Gat… 题解
 JavaScript 实现简易版贪吃蛇（Day_13）
IDEA 配置 Tomcat(详细)（Day_12）
常用数据库连接池配置及使用（Day_11）
大对象数据LOB的应用（Day_10）
IDEA中配置maven 全解析教程（Day_08）

原文地址：https://www.cnblogs.com/my376908915/p/6767922.html

深入理解java：3. NIO 编程

I/O简介

NIO基础

从文件中读取，需要如下三步：

控制buffer状态的三个变量

Selector

数据处理