NIO中篇和终篇

NIO中篇

FileChannel

概述

​ Java NIO中的FileCahnnel是连接文件的一个通道,这种通道不能设置成非阻塞状态模式,只有阻塞模式.

打开FileChannel

​ 在使用FileChannel之前，必须先打开它。但是，我们无法直接打开一个FileChannel，需要通过使用一个InputStream、OutputStream或RandomAccessFile来获取一个FileChannel实例。下面是通过RandomAccessFile打开FileChannel的示例：

RandomAccessFile fromFile = new RandomAccessFile("MPPRLogCodeCountService.properties", "rw");
            FileChannel fromFileChannel = fromFile.getChannel();

从FileChannel读取数据

调用多个read()方法之一从FileChannel中读取数据。如：

ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
int read = toFileChannel.read(byteBuffer);

​ 首先，分配一个Buffer。从FileChannel中读取的数据将被读到Buffer中。

然后，调用FileChannel.read()方法。该方法将数据从FileChannel读取到Buffer中。read()方法返回的int值表示了有多少字节被读到了Buffer中。如果返回-1，表示到了文件末尾。

向FileChannel写数据

使用FileChannel.write()方法向FileChannel写数据，该方法的参数是一个Buffer。如：

错误的demo:

 //往文件中写数据
            RandomAccessFile fromFile = new RandomAccessFile("MPPRLogCodeCountService.properties", "rw");
            FileChannel fromFileChannel = fromFile.getChannel();
            String newData = "New String to write to file..." + System.currentTimeMillis();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put(newData.getBytes());
            buffer.flip();
            while (buffer.hasRemaining()) {
                fromFileChannel.write(buffer);
            }
//            fromFileChannel.close();
            //读取FileChannel中的数据
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            int read = fromFileChannel.read(byteBuffer);
            while (read != -1) { //-1标识还没有读到最末位置,
                byteBuffer.flip(); //从写的模式切换成读的模式
                while (byteBuffer.hasRemaining()) {
                    System.out.print((char) byteBuffer.get());
                }
                byteBuffer.flip(); //缓存区数据读完切换写入模式往里面写数据
                fromFileChannel.read(byteBuffer);
            }

疑问:

• 此时从fromChannel读数据,发现之前写入fromChannel中的newData没有输出,这是为什么?但是文件中却添加了这句话.

• 还有一点就是会覆盖文件.

​ 我觉得根本的原因就是fromCahnnel的position的,当写数据时fromChannel的position发生变化,移动到了写入数据长度的位置,这是第一个问题的答案.

​ 第二个问题的解决方案就是指定写入数据的位置,因为默认写入fromChannel中是fromChannel的position初始的位置0开始的,写入多少position加多少,这样会覆盖后面的文件,并且再次读fromChannel中的数据需要重置position位置为0,然后再开始读.才能读到写入fromChannel"完整的数据",所谓完整就是覆盖后的数据.也不是完整的.最正确的解决方法就是写到最末的位置.

正确的demo

  //往文件中写数据
            RandomAccessFile fromFile = new RandomAccessFile("MPPRLogCodeCountService.properties", "rw");
            FileChannel fromFileChannel = fromFile.getChannel();
            System.out.println("原来的长度: " + fromFileChannel.size() + ", " + fromFileChannel.position());
            String newData = " \nnewData=New String to write to file..." + System.currentTimeMillis();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put(newData.getBytes());
            buffer.flip();
            while (buffer.hasRemaining()) {
                fromFileChannel.write(buffer, fromFileChannel.size());
            }

            //读取FileChannel中的数据
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            int read = fromFileChannel.read(byteBuffer);
            while (read != -1) { //-1标识还没有读到最末位置,
                byteBuffer.flip(); //从写的模式切换成读的模式
                while (byteBuffer.hasRemaining()) {
                    System.out.print((char) byteBuffer.get());
                }
                byteBuffer.flip(); //缓存区数据读完切换写入模式往里面写数据
                fromFileChannel.read(byteBuffer);
            }

关闭FileChannel

用完FileChannel后必须将其关闭。如：

fromChannel.close();

FileChannel的position方法

有时可能需要在FileChannel的某个特定位置进行数据的读/写操作。可以通过调用position()方法获取FileChannel的当前位置。

也可以通过调用position(long pos)方法设置FileChannel的当前位置。

这里有两个例子:

1	long pos = channel.position();

2	channel.position(pos +``123``);

​ 如果将位置设置在文件结束符之后，然后试图从文件通道中读取数据，读方法将返回-1 —— 文件结束标志。

​ 如果将位置设置在文件结束符之后，然后向通道中写数据，文件将撑大到当前位置并写入数据。这可能导致“文件空洞”，磁盘上物理文件中写入的数据间有空隙。

FileChannel的size方法

FileChannel实例的size()方法将返回该实例所关联文件的大小。如:

long fileSize = channel.size();

FileChannel的truncate方法

可以使用FileChannel.truncate()方法截取一个文件。截取文件时，文件将中指定长度后面的部分将被删除。如：

channel.truncate(1024);

这个例子截取文件的前1024个字节。

FileChannel的force方法

FileChannel.force()方法将通道里尚未写入磁盘的数据强制写到磁盘上。出于性能方面的考虑，操作系统会将数据缓存在内存中，所以无法保证写入到FileChannel里的数据一定会即时写到磁盘上。要保证这一点，需要调用force()方法。

force()方法有一个boolean类型的参数，指明是否同时将文件元数据（权限信息等）写到磁盘上。

下面的例子同时将文件数据和元数据强制写到磁盘上：

channel.force(true);

SocketChannel

​ Java NIO中的SocketChannel是一个连接到TCP网络套接字的通道。可以通过以下2种方式创建SocketChannel：

• 打开一个SocketChannel并连接到互联网上的某台服务器。
• 一个新连接到达ServerSocketChannel时，会创建一个SocketChannel。

打开SocketChannel

 try (
                SocketChannel socketChannel = SocketChannel.open();
        ) {
            socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
        } catch (Exception e) {
            e.printStackTrace();
        }

关闭SocketChannel

两种方式

• 一种就是使用try-with-sources
• 另一种就是socketChannel.close()

从SocketChannel中读数据

 try (
                SocketChannel socketChannel = SocketChannel.open();
        ) {
            socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int read = socketChannel.read(buffer);
        } catch (Exception e) {
            e.printStackTrace();
        }

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

写入数据到SocketChannel

try (
                SocketChannel socketChannel = SocketChannel.open();
        ) {
            String write = "Hello! I from HZ. My name is Mr.Wang? What's your name ? Do you want to make friend with me?";
            socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.clear();
            buffer.put(write.getBytes());
            buffer.flip();
            //只要buffer中有数据就一直读数据
            while (buffer.hasRemaining()){
                socketChannel.write(buffer);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

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

非阻塞模式

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

 try (
                SocketChannel socketChannel = SocketChannel.open();
        ) {
            socketChannel.configureBlocking(false);
            String write = "Hello! I from HZ. My name is Mr.Wang? What's your name ? Do you want to make friend with me?";
            socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.clear();
            buffer.put(write.getBytes());
            buffer.flip();
            //只要buffer中有数据就一直读数据
            while (buffer.hasRemaining()){
                while (!socketChannel.finishConnect()){
                    socketChannel.write(buffer);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

write()

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

read()

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

非阻塞模式与选择器

​ 非阻塞模式与选择器搭配会工作的更好，通过将一或多个SocketChannel注册到Selector，可以询问选择器哪个通道已经准备好了读取，写入等。

ServerSocketChannel

​ java NIO中的 ServerSocketChannel 是一个可以监听新进来的TCP连接的通道, 就像标准IO中的ServerSocket一样。ServerSocketChannel类在 java.nio.channels包中。

​ 示例:

try (
                ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        ) {
            serverSocketChannel.socket().bind(new InetSocketAddress(8080));

            while (true){
                SocketChannel socketChannel = serverSocketChannel.accept();
                //对socketChannel的一些业务逻辑处理
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

打开 ServerSocketChannel

​ 通过调用 ServerSocketChannel.open() 方法来打开ServerSocketChannel.

关闭ServerSocketChannel

• try-with-sources的方式关闭
• serverSocketChannel.close()的方式关闭

监听新进来的连接

​ 通过 ServerSocketChannel.accept() 方法监听新进来的连接。当 accept()方法返回的时候,它返回一个包含新进来的连接的 SocketChannel。因此, accept()方法会一直阻塞到有新连接到达。通常不会仅仅只监听一个连接,在while循环中调用 accept()方法. 如下面的例子：

   while (true){
                SocketChannel socketChannel = serverSocketChannel.accept();
                //对socketChannel的一些业务逻辑处理
            }

当然,也可以在while循环中使用除了true以外的其它退出准则。

非阻塞模式

​ ServerSocketChannel可以设置成非阻塞模式。在非阻塞模式下，accept() 方法会立刻返回，如果还没有新进来的连接,返回的将是null。 因此，需要检查返回的SocketChannel是否是null.如

try (
                ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        ) {
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.socket().bind(new InetSocketAddress(8080));
            while (true){
                SocketChannel socketChannel = serverSocketChannel.accept();
                if(ObjectUtils.isNotEmpty(socketChannel)){
                    //对socketChannel的一些业务逻辑处理
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

DatagramChannel

​ Java NIO中的DatagramChannel是一个能收发UDP包的通道。因为UDP是无连接的网络协议，所以不能像其它通道那样读取和写入。它发送和接收的是数据包。

打开DatagramChannel

try (
                DatagramChannel datagramChannel = DatagramChannel.open();
        ) {
            datagramChannel.socket().bind(new InetSocketAddress(8080));
        } catch (Exception e) {
            e.printStackTrace();
        }

接收数据

通过receive()方法从DatagramChannel接收数据，如：

 try (
                DatagramChannel datagramChannel = DatagramChannel.open();
        ) {
            datagramChannel.socket().bind(new InetSocketAddress(8080));
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            datagramChannel.receive(byteBuffer);
        } catch (Exception e) {
            e.printStackTrace();
        }

​ receive()方法会将接收到的数据包内容复制到指定的Buffer. 如果Buffer容不下收到的数据，多出的数据将被丢弃。

发送数据

通过send()方法从DatagramChannel发送数据，如:

try (
                DatagramChannel datagramChannel = DatagramChannel.open();
        ) {
            datagramChannel.socket().bind(new InetSocketAddress(8080));
            String write = "Hello! I from HZ. My name is Mr.Wang? What's your name ? Do you want to make friend with me?";
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.clear();
            buffer.put(write.getBytes());
            buffer.flip();
            while (buffer.hasRemaining()){
                datagramChannel.send(buffer, new InetSocketAddress("jenkov.com", 8080));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

​ 这个例子发送一串字符到”jenkov.com”服务器的UDP端口80。 因为服务端并没有监控这个端口，所以什么也不会发生。也不会通知你发出的数据包是否已收到，因为UDP在数据传送方面没有任何保证。

连接到特定的地址

​ 可以将DatagramChannel“连接”到网络中的特定地址的。由于UDP是无连接的，连接到特定地址并不会像TCP通道那样创建一个真正的连接。而是锁住DatagramChannel ，让其只能从特定地址收发数据。

​ 这里有个例子:

channel.connect(new InetSocketAddress("jenkov.com", 80));

​ 当连接后，也可以使用read()和write()方法，就像在用传统的通道一样。只是在数据传送方面没有任何保证。这里有几个例子：

int bytesRead = channel.read(buf);
int bytesWritten = channel.write(but);

NIO深入理解及拓展

Pipe

​ java NIO 管道是2个线程之间的单向数据连接。Pipe有一个source通道和一个sink通道。数据会被写到sink通道，从source通道读取。

创建管道

通过Pipe.open()方法打开管道。例如：

Pipe pipe = Pipe.open();

向管道写数据

要向管道写数据，需要访问sink通道。像这样：

try {
            Pipe pipe = Pipe.open();
            Pipe.SinkChannel sinkChannel = pipe.sink();
            String write = "Hello! I from HZ. My name is Mr.Wang? What's your name ? Do you want to make friend with me?";
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            byteBuffer.put(write.getBytes());
            byteBuffer.flip();
            while (byteBuffer.hasRemaining()) {
                sinkChannel.write(byteBuffer);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

管道读取数据

从读取管道的数据，需要访问source通道，像这样：

 public static void readDataFromSource() {
        try {
            Pipe pipe = Pipe.open();
            Pipe.SinkChannel sinkChannel = pipe.sink();
            String write = "Hello! I from HZ. My name is Mr.Wang? What's your name ? Do you want to make friend with me?";
            ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
            writeBuffer.put(write.getBytes());
            writeBuffer.flip();
            while (writeBuffer.hasRemaining()) {
                sinkChannel.write(writeBuffer);
            }

            Pipe.SourceChannel sourceChannel = pipe.source();
            ByteBuffer readBuffer = ByteBuffer.allocate(1024);
            int read = sourceChannel.read(readBuffer);
            readBuffer.flip();
            while (read != -1){
                while (readBuffer.hasRemaining()){
                    System.out.print((char)readBuffer.get());
                }
                readBuffer.flip();
                sourceChannel.read(readBuffer);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

read()方法返回的int值会告诉我们多少字节被读进了缓冲区。

Java NIO和IO区别

​ 当学习了Java NIO和IO的API后，一个问题马上涌入脑海：我应该何时使用IO，何时使用NIO呢？在本文中，我会尽量清晰地解析Java NIO和IO的差异、它们的使用场景，以及它们如何影响您的代码设计。

java NIO和IO的主要区别

​ 下表总结了Java NIO和IO之间的主要差别，我会更详细地描述表中每部分的差异:

IO	NIO
面向流	面向缓冲
阻塞IO	非阻塞IO
无	选择器

面向流与面向缓冲

​ Java NIO和IO之间第一个最大的区别是:IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。 Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。

阻塞与非阻塞IO

​ Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。

Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

选择器（Selectors）

​ Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。

NIO和IO如何影响应用程序的设计

无论您选择IO或NIO工具箱，可能会影响您应用程序设计的以下几个方面：

• 对NIO或IO类的API调用。
• 数据处理。
• 用来处理数据的线程数。

API调用

当然，使用NIO的API调用时看起来与使用IO时有所不同，但这并不意外，因为并不是仅从一个InputStream逐字节读取，而是数据必须先读入缓冲区再处理。

数据处理

使用纯粹的NIO设计相较IO设计，数据处理也受到影响。

在IO设计中，我们从InputStream或 Reader逐字节读取数据。假设你正在处理一基于行的文本数据流，例如：

Name: Anna
Age: 25
Email: anna@mailserver.com
Phone: 1234567890

该文本行的流可以这样处理：

try (FileInputStream fis = new FileInputStream("src/a.txt");
				BufferedInputStream bis = new BufferedInputStream(fis);) {
			byte[] b = new byte[1024];
			int length = 0;
			while ((length = bis.read(b)) != -1) {
				String str = new String(b, 0, length);
				System.out.println(str);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}

​ 请注意处理状态由程序执行多久决定。换句话说，一旦reader.readLine()方法返回，你就知道肯定文本行就已读完， readline()阻塞直到整行读完，这就是原因。你也知道此行包含名称；同样，第二个readline()调用返回的时候，你知道这行包含年龄等。 正如你可以看到，该处理程序仅在有新数据读入时运行，并知道每步的数据是什么。一旦正在运行的线程已处理过读入的某些数据，该线程不会再回退数据（大多如此）。下图也说明了这条原则：

（Java IO: 从一个阻塞的流中读数据） 而一个NIO的实现会有所不同，下面是一个简单的例子：

ByteBuffer buffer = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buffer);

​ 注意第二行，从通道读取字节到ByteBuffer。当这个方法调用返回时，你不知道你所需的所有数据是否在缓冲区内。你所知道的是，该缓冲区包含一些字节，这使得处理有点困难。假设第一次 read(buffer)调用后，读入缓冲区的数据只有半行，例如，“Name:An”，你能处理数据吗？显然不能，需要等待，直到整行数据读入缓存，在此之前，对数据的任何处理毫无意义。所以，你怎么知道是否该缓冲区包含足够的数据可以处理呢？好了，你不知道。发现的方法只能查看缓冲区中的数据。其结果是，在你知道所有数据都在缓冲区里之前，你必须检查几次缓冲区的数据。这不仅效率低下，而且可以使程序设计方案杂乱不堪。例如：

ByteBuffer buffer = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buffer);
while(! bufferFull(bytesRead) ) {
	bytesRead = inChannel.read(buffer);
}

​ bufferFull()方法必须跟踪有多少数据读入缓冲区，并返回真或假，这取决于缓冲区是否已满。换句话说，如果缓冲区准备好被处理，那么表示缓冲区满了.bufferFull()方法扫描缓冲区，但必须保持在bufferFull（）方法被调用之前状态相同。如果没有，下一个读入缓冲区的数据可能无法读到正确的位置。这是不可能的，但却是需要注意的又一问题。如果缓冲区已满，它可以被处理。如果它不满，并且在你的实际案例中有意义，你或许能处理其中的部分数据。但是许多情况下并非如此。下图展示了“缓冲区数据循环就绪”：Java NIO:从一个通道里读数据，直到所有的数据都读到缓冲区里.

用来处理数据的线程数

​ NIO可让您只使用一个（或几个）单线程管理多个通道（网络连接或文件），但付出的代价是解析数据可能会比从一个阻塞流中读取数据更复杂。如果需要管理同时打开的成千上万个连接，这些连接每次只是发送少量的数据，例如聊天服务器，实现NIO的服务器可能是一个优势。同样，如果你需要维持许多打开的连接到其他计算机上，如P2P网络中，使用一个单独的线程来管理你所有出站连接，可能是一个优势。一个线程多个连接的设计方案如下图所示：

​