JDK 1.4中的java.nio.*包中引入新的Java I/O库,其目的是提高速度。实际上,“旧”的I/O包已经使用NIO重新实现过,即使我们不显式的使用NIO编程,也能从中受益。
在《Java编程思想》读到**“即使我们不显式的使用NIO编程,也能从中受益”的时候,我是挺在意的,所以:我们测试**一下使用NIO复制文件和传统IO复制文件的性能:
import java.io.*; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; public class SimpleFileTransferTest { private long transferFile(File source, File des) throws IOException { long startTime = System.currentTimeMillis(); if (!des.exists()) des.createNewFile(); BufferedInputStream bis = new BufferedInputStream(new FileInputStream(source)); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(des)); //将数据源读到的内容写入目的地--使用数组 byte[] bytes = new byte[1024 * 1024]; int len; while ((len = bis.read(bytes)) != -1) { bos.write(bytes, 0, len); } long endTime = System.currentTimeMillis(); return endTime - startTime; } private long transferFileWithNIO(File source, File des) throws IOException { long startTime = System.currentTimeMillis(); if (!des.exists()) des.createNewFile(); RandomAccessFile read = new RandomAccessFile(source, "rw"); RandomAccessFile write = new RandomAccessFile(des, "rw"); FileChannel readChannel = read.getChannel(); FileChannel writeChannel = write.getChannel(); ByteBuffer byteBuffer = ByteBuffer.allocate(1024 * 1024);//1M缓冲区 while (readChannel.read(byteBuffer) > 0) { byteBuffer.flip(); writeChannel.write(byteBuffer); byteBuffer.clear(); } writeChannel.close(); readChannel.close(); long endTime = System.currentTimeMillis(); return endTime - startTime; } public static void main(String[] args) throws IOException { SimpleFileTransferTest simpleFileTransferTest = new SimpleFileTransferTest(); File sourse = new File("F:\\电影\\[电影天堂www.dygod.cn]猜火车-cd1.rmvb"); File des = new File("X:\\Users\\ozc\\Desktop\\io.avi"); File nio = new File("X:\\Users\\ozc\\Desktop\\nio.avi"); long time = simpleFileTransferTest.transferFile(sourse, des); System.out.println(time + ":普通字节流时间"); long timeNio = simpleFileTransferTest.transferFileWithNIO(sourse, nio); System.out.println(timeNio + ":NIO时间"); } } 复制代码
我分别测试了文件大小为13M,40M,200M的:
1.1为什么要使用NIO
可以看到使用过NIO重新实现过的传统IO根本不虚,在大文件下效果还比NIO要好(当然了,个人几次的测试,或许不是很准)
那这意味着我们可以不使用/学习NIO了吗?
答案是否定的,IO操作往往在两个场景下会用到:
NIO的魅力:在网络中使用IO就可以体现出来了!
首先我们来看看IO和NIO的区别:
NIO主要有三个核心部分组成:
2.1buffer缓冲区和Channel管道
在NIO中并不是以流的方式来处理数据的,而是以buffer缓冲区和Channel管道配合使用来处理数据。
简单理解一下:
而我们的NIO就是通过Channel管道运输着存储数据的Buffer缓冲区的来实现数据的处理!
相对于传统IO而言,流是单向的。对于NIO而言,有了Channel管道这个概念,我们的读写都是双向的(铁路上的火车能从广州去北京、自然就能从北京返还到广州)!
2.1.1buffer缓冲区核心要点
我们来看看Buffer缓冲区有什么值得我们注意的地方。
Buffer是缓冲区的抽象类:
其中ByteBuffer是用得最多的实现类(在管道中读写字节数据)。
拿到一个缓冲区我们往往会做什么?很简单,就是读取缓冲区的数据/写数据到缓冲区中。所以,缓冲区的核心方法就是:
Buffer类维护了4个核心变量属性来提供关于其所包含的数组的信息。它们是:
2.1.2buffer代码演示
首先展示一下是如何创建缓冲区的,核心变量的值是怎么变化的。
public static void main(String[] args) { // 创建一个缓冲区 ByteBuffer byteBuffer = ByteBuffer.allocate(1024); // 看一下初始时4个核心变量的值 System.out.println("初始时-->limit--->"+byteBuffer.limit()); System.out.println("初始时-->position--->"+byteBuffer.position()); System.out.println("初始时-->capacity--->"+byteBuffer.capacity()); System.out.println("初始时-->mark--->" + byteBuffer.mark()); System.out.println("--------------------------------------"); // 添加一些数据到缓冲区中 String s = "Java3y"; byteBuffer.put(s.getBytes()); // 看一下初始时4个核心变量的值 System.out.println("put完之后-->limit--->"+byteBuffer.limit()); System.out.println("put完之后-->position--->"+byteBuffer.position()); System.out.println("put完之后-->capacity--->"+byteBuffer.capacity()); System.out.println("put完之后-->mark--->" + byteBuffer.mark()); } 复制代码
运行结果:
现在我想要从缓存区拿数据,怎么拿呀??NIO给了我们一个flip()方法。这个方法可以改动position和limit的位置!
还是上面的代码,我们flip()一下后,再看看4个核心属性的值会发生什么变化:
很明显的是:
看到这里的同学可能就会想到了:当调用完filp()时:limit是限制读到哪里,而position是从哪里读
一般我们称filp()为**“切换成读模式”**
切换成读模式之后,我们就可以读取缓冲区的数据了:
// 创建一个limit()大小的字节数组(因为就只有limit这么多个数据可读) byte[] bytes = new byte[byteBuffer.limit()]; // 将读取的数据装进我们的字节数组中 byteBuffer.get(bytes); // 输出数据 System.out.println(new String(bytes, 0, bytes.length)); 复制代码
随后输出一下核心变量的值看看:
读完我们还想写数据到缓冲区,那就使用clear()函数,这个函数会“清空”缓冲区:
2.1.3FileChannel通道核心要点
Channel通道只负责传输数据、不直接操作数据的。操作数据都是通过Buffer缓冲区来进行操作!
// 1. 通过本地IO的方式来获取通道 FileInputStream fileInputStream = new FileInputStream("F:\\3yBlog\\JavaEE常用框架\\Elasticsearch就是这么简单.md"); // 得到文件的输入通道 FileChannel inchannel = fileInputStream.getChannel(); // 2. jdk1.7后通过静态方法.open()获取通道 FileChannel.open(Paths.get("F:\\3yBlog\\JavaEE常用框架\\Elasticsearch就是这么简单2.md"), StandardOpenOption.WRITE); 复制代码
使用FileChannel配合缓冲区实现文件复制的功能:
使用内存映射文件的方式实现文件复制的功能(直接操作缓冲区):
通道之间通过transfer()实现数据的传输(直接操作缓冲区):
2.1.4直接与非直接缓冲区
使用直接缓冲区有两种方式:
2.1.5scatter和gather、字符集
这个知识点我感觉用得挺少的,不过很多教程都有说这个知识点,我也拿过来说说吧:
分散读取
聚集写入
字符集(只要编码格式和解码格式一致,就没问题了)
文件的IO就告一段落了,我们来学习网络中的IO~~~为了更好地理解NIO,我们先来学习一下IO的模型~
根据UNIX网络编程对I/O模型的分类,在UNIX可以归纳成5种I/O模型:
3.0学习I/O模型需要的基础
3.0.1文件描述符
Linux 的内核将所有外部设备都看做一个文件来操作,对一个文件的读写操作会调用内核提供的系统命令(api),返回一个file descriptor(fd,文件描述符)。而对一个socket的读写也会有响应的描述符,称为socket fd(socket文件描述符),描述符就是一个数字,指向内核中的一个结构体(文件路径,数据区等一些属性)。
3.0.2用户空间和内核空间
为了保证用户进程不能直接操作内核(kernel),保证内核的安全,操心系统将虚拟空间划分为两部分
3.0.3I/O运行过程
我们来看看IO在系统中的运行是怎么样的(我们以read为例)
可以发现的是:当应用程序调用read方法时,是需要等待的--->从内核空间中找数据,再将内核空间的数据拷贝到用户空间的。
下面只讲解用得最多的3个I/0模型:
3.1阻塞I/O模型
在进程(用户)空间中调用recvfrom,其系统调用直到数据包到达且被复制到应用进程的缓冲区中或者发生错误时才返回,在此期间一直等待。
3.2非阻塞I/O模型
recvfrom从应用层到内核的时候,如果没有数据就直接返回一个EWOULDBLOCK错误,一般都对非阻塞I/O模型进行轮询检查这个状态,看内核是不是有数据到来。
3.3I/O复用模型
前面也已经说了:在Linux下对文件的操作是利用文件描述符(file descriptor)来实现的。
在Linux下它是这样子实现I/O复用模型的:
比如poll()函数是这样子的:int poll(struct pollfd *fds,nfds_t nfds, int timeout);
其中 pollfd 结构定义如下:
struct pollfd { int fd; /* 文件描述符 */ short events; /* 等待的事件 */ short revents; /* 实际发生了的事件 */ }; 复制代码
select/epoll的优势并不是对于单个连接能处理得更快,而是在于能处理更多的连接。
3.4I/O模型总结
正经的描述都在上面给出了,不知道大家理解了没有。下面我举几个例子总结一下这三种模型:
阻塞I/O:
非阻塞I/O:
I/O复用模型:
4.1NIO基础继续讲解
回到我们最开始的图:
NIO被叫为 no-blocking io,其实是在网络这个层次中理解的,对于FileChannel来说一样是阻塞。
我们前面也仅仅讲解了FileChannel,对于我们网络通信是还有几个Channel的~
所以说:我们通常使用NIO是在网络中使用的,网上大部分讨论NIO都是在网络通信的基础之上的!说NIO是非阻塞的NIO也是网络中体现的!
从上面的图我们可以发现还有一个Selector选择器这么一个东东。从一开始我们就说过了,nio的核心要素有:
我们在网络中使用NIO往往是I/O模型的多路复用模型!
4.2NIO阻塞形态
为了更好地理解,我们先来写一下NIO在网络中是阻塞的状态代码,随后看看非阻塞是怎么写的就更容易理解了。
客户端:
public class BlockClient { public static void main(String[] args) throws IOException { // 1. 获取通道 SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 6666)); // 2. 发送一张图片给服务端吧 FileChannel fileChannel = FileChannel.open(Paths.get("X:\\Users\\ozc\\Desktop\\新建文件夹\\1.png"), StandardOpenOption.READ); // 3.要使用NIO,有了Channel,就必然要有Buffer,Buffer是与数据打交道的呢 ByteBuffer buffer = ByteBuffer.allocate(1024); // 4.读取本地文件(图片),发送到服务器 while (fileChannel.read(buffer) != -1) { // 在读之前都要切换成读模式 buffer.flip(); socketChannel.write(buffer); // 读完切换成写模式,能让管道继续读取文件的数据 buffer.clear(); } // 5. 关闭流 fileChannel.close(); socketChannel.close(); } } 复制代码
服务端:
public class BlockServer { public static void main(String[] args) throws IOException { // 1.获取通道 ServerSocketChannel server = ServerSocketChannel.open(); // 2.得到文件通道,将客户端传递过来的图片写到本地项目下(写模式、没有则创建) FileChannel outChannel = FileChannel.open(Paths.get("2.png"), StandardOpenOption.WRITE, StandardOpenOption.CREATE); // 3. 绑定链接 server.bind(new InetSocketAddress(6666)); // 4. 获取客户端的连接(阻塞的) SocketChannel client = server.accept(); // 5. 要使用NIO,有了Channel,就必然要有Buffer,Buffer是与数据打交道的呢 ByteBuffer buffer = ByteBuffer.allocate(1024); // 6.将客户端传递过来的图片保存在本地中 while (client.read(buffer) != -1) { // 在读之前都要切换成读模式 buffer.flip(); outChannel.write(buffer); // 读完切换成写模式,能让管道继续读取文件的数据 buffer.clear(); } // 7.关闭通道 outChannel.close(); client.close(); server.close(); } } 复制代码
结果就可以将客户端传递过来的图片保存在本地了:
此时服务端保存完图片想要告诉客户端已经收到图片啦:
客户端接收服务端带过来的数据:
如果仅仅是上面的代码是不行的!这个程序会阻塞起来!
于是客户端在写完数据给服务端时,显式告诉服务端已经发完数据了!
4.3NIO非阻塞形态
如果使用非阻塞模式的话,那么我们就可以不显式告诉服务器已经发完数据了。我们下面来看看怎么写:
客户端:
public class NoBlockClient { public static void main(String[] args) throws IOException { // 1. 获取通道 SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 6666)); // 1.1切换成非阻塞模式 socketChannel.configureBlocking(false); // 2. 发送一张图片给服务端吧 FileChannel fileChannel = FileChannel.open(Paths.get("X:\\Users\\ozc\\Desktop\\新建文件夹\\1.png"), StandardOpenOption.READ); // 3.要使用NIO,有了Channel,就必然要有Buffer,Buffer是与数据打交道的呢 ByteBuffer buffer = ByteBuffer.allocate(1024); // 4.读取本地文件(图片),发送到服务器 while (fileChannel.read(buffer) != -1) { // 在读之前都要切换成读模式 buffer.flip(); socketChannel.write(buffer); // 读完切换成写模式,能让管道继续读取文件的数据 buffer.clear(); } // 5. 关闭流 fileChannel.close(); socketChannel.close(); } } 复制代码
服务端:
public class NoBlockServer { public static void main(String[] args) throws IOException { // 1.获取通道 ServerSocketChannel server = ServerSocketChannel.open(); // 2.切换成非阻塞模式 server.configureBlocking(false); // 3. 绑定连接 server.bind(new InetSocketAddress(6666)); // 4. 获取选择器 Selector selector = Selector.open(); // 4.1将通道注册到选择器上,指定接收“监听通道”事件 server.register(selector, SelectionKey.OP_ACCEPT); // 5. 轮训地获取选择器上已“就绪”的事件--->只要select()>0,说明已就绪 while (selector.select() > 0) { // 6. 获取当前选择器所有注册的“选择键”(已就绪的监听事件) Iteratoriterator = selector.selectedKeys().iterator(); // 7. 获取已“就绪”的事件,(不同的事件做不同的事) while (iterator.hasNext()) { SelectionKey selectionKey = iterator.next(); // 接收事件就绪 if (selectionKey.isAcceptable()) { // 8. 获取客户端的链接 SocketChannel client = server.accept(); // 8.1 切换成非阻塞状态 client.configureBlocking(false); // 8.2 注册到选择器上-->拿到客户端的连接为了读取通道的数据(监听读就绪事件) client.register(selector, SelectionKey.OP_READ); } else if (selectionKey.isReadable()) { // 读事件就绪 // 9. 获取当前选择器读就绪状态的通道 SocketChannel client = (SocketChannel) selectionKey.channel(); // 9.1读取数据 ByteBuffer buffer = ByteBuffer.allocate(1024); // 9.2得到文件通道,将客户端传递过来的图片写到本地项目下(写模式、没有则创建) FileChannel outChannel = FileChannel.open(Paths.get("2.png"), StandardOpenOption.WRITE, StandardOpenOption.CREATE); while (client.read(buffer) > 0) { // 在读之前都要切换成读模式 buffer.flip(); outChannel.write(buffer); // 读完切换成写模式,能让管道继续读取文件的数据 buffer.clear(); } } // 10. 取消选择键(已经处理过的事件,就应该取消掉了) iterator.remove(); } } } } 复制代码
还是刚才的需求:服务端保存了图片以后,告诉客户端已经收到图片了。
在服务端上只要在后面写些数据给客户端就好了:
在客户端上要想获取得到服务端的数据,也需要注册在register上(监听读事件)!
public class NoBlockClient2 { public static void main(String[] args) throws IOException { // 1. 获取通道 SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 6666)); // 1.1切换成非阻塞模式 socketChannel.configureBlocking(false); // 1.2获取选择器 Selector selector = Selector.open(); // 1.3将通道注册到选择器中,获取服务端返回的数据 socketChannel.register(selector, SelectionKey.OP_READ); // 2. 发送一张图片给服务端吧 FileChannel fileChannel = FileChannel.open(Paths.get("X:\\Users\\ozc\\Desktop\\新建文件夹\\1.png"), StandardOpenOption.READ); // 3.要使用NIO,有了Channel,就必然要有Buffer,Buffer是与数据打交道的呢 ByteBuffer buffer = ByteBuffer.allocate(1024); // 4.读取本地文件(图片),发送到服务器 while (fileChannel.read(buffer) != -1) { // 在读之前都要切换成读模式 buffer.flip(); socketChannel.write(buffer); // 读完切换成写模式,能让管道继续读取文件的数据 buffer.clear(); } // 5. 轮训地获取选择器上已“就绪”的事件--->只要select()>0,说明已就绪 while (selector.select() > 0) { // 6. 获取当前选择器所有注册的“选择键”(已就绪的监听事件) Iteratoriterator = selector.selectedKeys().iterator(); // 7. 获取已“就绪”的事件,(不同的事件做不同的事) while (iterator.hasNext()) { SelectionKey selectionKey = iterator.next(); // 8. 读事件就绪 if (selectionKey.isReadable()) { // 8.1得到对应的通道 SocketChannel channel = (SocketChannel) selectionKey.channel(); ByteBuffer responseBuffer = ByteBuffer.allocate(1024); // 9. 知道服务端要返回响应的数据给客户端,客户端在这里接收 int readBytes = channel.read(responseBuffer); if (readBytes > 0) { // 切换读模式 responseBuffer.flip(); System.out.println(new String(responseBuffer.array(), 0, readBytes)); } } // 10. 取消选择键(已经处理过的事件,就应该取消掉了) iterator.remove(); } } } } 复制代码
测试结果:
下面就简单总结一下使用NIO时的要点:
4.4管道和DataGramChannel
这里我就不再讲述了,最难的TCP都讲了,UDP就很简单了。
UDP:
管道:
总的来说NIO也是一个比较重要的知识点,因为它是学习netty的基础~