浅尝JavaNIO

Posted 2020-11-23 ellen-eyes

本文将通过JavaNIO实现文件的局域网发送功能。

目的：

1.为了体验零拷贝

2.为了体验NIO的Channel，Buffer，Selector

3.为了体验NIO方式网络传输文件和传统网络方式传输文件的差异（性能差异）。

什么是零拷贝：

　　那先来说说传统的文件传输：在本地读取文件（FileInputStream）通过网络传输(socket.getInputStream，socket.getOutputstream)发送到另一台设备进行存储（FileOutPutStream）过程，以及在操作这些流所用到的缓存（自定义byte数组或者各种BufferdInputStream/BufferdOutputStream）中，这些操作都在我们浅显来看，是这样的：磁盘——网络——磁盘的过程；稍微深一层次的，应该是这样的：磁盘—内存—网络—内存—磁盘的过程；再深一层次的，应该是这样：磁盘—操作系统内存（内核态-从磁盘读取过来）—应用程序内存（用户态）—操作系统内存（内核态-网络准备发送）—网络中传输—操作系统内存（内核态-网络接收）—应用程序内存（用户态）—操作系统内存（内核态-准备存磁盘）—磁盘。

　　重点来了，零拷贝（需要操作系统支持）就是用来减少甚至杜绝操作系统内存（内核态）到应用程序内存（用户态）的拷贝过程的。让cpu不要浪费在这种内存间拷贝的操作上，而是用在其他高效的计算上，零拷贝通过内存地址映射的方式，让网络/磁盘直接到系统内存中（内核态）中读取缓存的数据进行网络传输/本地存储，而不用再让数据到应用程序内存中来”转一圈“。

　　java中NIO中的的FileChannel类的transferTo、transferFrom就能够实现这个操作，直接操作内核态，不经过用户态。

接下来就是NIO了：

1.Channel：

　　我一直把Channel看成是双向流，这一点在其实现类的API中可以很明显的看出来，在使用过程中，通过对API的调用，更能感同身受。

　　最常用的实现类：

　　1.FileChannel，常用API如下（先列在这，后期再来逐一梳理）：

 1 public abstract class FileChannel extends AbstractInterruptibleChannel
 2     implements SeekableByteChannel, GatheringByteChannel, ScatteringByteChannel
 3 {
 4     //打开或者创建（无则创建）一个文件，成功后返回该文件的Channel对象
 5     public static FileChannel open(Path path, OpenOption... options)
 6 
 7     public static FileChannel open(Path path,Set<? extends OpenOption> options, FileAttribute<?>... attrs)
 8     //从文件读
 9     public abstract int read(ByteBuffer dst) throws IOException;
10     public abstract long read(ByteBuffer[] dsts, int offset, int length)throws IOException;
11     public final long read(ByteBuffer[] dsts) throws IOException
12     //写文件
13     public abstract int write(ByteBuffer src) throws IOException;
14     public abstract long write(ByteBuffer[] srcs, int offset, int length)
15     public final long write(ByteBuffer[] srcs) throws IOException
16     //截取指定大小的文件
17     public abstract FileChannel truncate(long size) throws IOException;
18     //强制将所有对此通道的文件更新写入包含该文件的存储设备中
19     public abstract void force(boolean metaData) throws IOException;
20     //将字节从此通道的文件传输到给定的可写入字节通道(支持零拷贝)
21     public abstract long transferTo(long position, long count,WritableByteChannel target) throws IOException
22     //将字节从给定的可读取字节通道传输到此通道的文件中(支持零拷贝)
23     public abstract long transferFrom(ReadableByteChannel src, long position,long count) throws IOException
24     //将指定的文件映射到内存中
25     public abstract MappedByteBuffer map(MapMode mode, long position, long size) throws IOException;

　　2.SocketChannel

　　2.1 SocketChannel,常用API如下：

 1 public abstract class SocketChannel
 2     extends AbstractSelectableChannel
 3     implements ByteChannel, ScatteringByteChannel, GatheringByteChannel, NetworkChannel
 4 {
 5     //打开套接字通道并将其连接到远程地址。
 6     public static SocketChannel open(SocketAddress remote) throws IOException
 7     //开启连接，可以使阻塞和非阻塞，在普通socket中，此处是阻塞的
 8     public abstract boolean connect(SocketAddress remote) throws IOException
 9     //完成套接字通道的连接过程。
10     public abstract boolean finishConnect() throws IOException
11     //将字节序列从此通道中读入给定的缓冲区。
12     public abstract int read(ByteBuffer dst)throws IOException   
13     public abstract long read(ByteBuffer[] dsts,int offset,int length) throws IOException
14     public final long read(ByteBuffer[] dsts) throws IOException
15     //将字节序列从给定的缓冲区中写入此通道。 
16     public abstract int write(ByteBuffer src) throws IOException
17     public abstract long write(ByteBuffer[] srcs,int offset, int length) throws IOException
18     public final long write(ByteBuffer[] srcs) throws IOException
19 }

 　　2.2SocketServerChannel,常用API如下：

 1 public abstract class ServerSocketChannel extends AbstractSelectableChannel  implements NetworkChannel
 2 {
 3     //打开服务器套接字通道，开启网络服务器第一步
 4     public static ServerSocketChannel open() throws IOException
 5     //接受到此通道套接字的连接
 6     public abstract SocketChannel accept() throws IOException
 7     //继承自java.nio.channels.spi.AbstractSelectableChannel，设置阻塞模式（阻塞或者非阻塞）
 8     public final SelectableChannel configureBlocking(boolean block) throws IOException
 9     //继承自java.nio.channels.SelectableChannel，实现选择网络模型
10     register(Selector sel, int ops) throws ClosedChannelException
11 }

2.Buffer

　　Buffer是一个虚类，他的子类有ByteBuffer,ShortBuffer,IntBuffer,LongBuffer,FloatBuffer,DoubleBuffer,CharBuffer基本类型都有对应的Buffer，但是bollean没有，这些子类也是虚类。

　　在Buffer类中这，需要注意几个成员变量，及几个实现方法：

 1 public abstract class Buffer {
 2     //标志位，可以通过设置此变量的值，reset()方法可以将操作指针下标回滚到该位置
 3     private int mark = -1;
 4     //当前操作指针的下标
 5     private int position = 0;
 6     //当前有效数据的最大范围，也可以说是当前操作指针能操作到的最大范围，类似集合的size()方法的返回值。
 7     private int limit;
 8     //当前buffer的最大值（容量），类似于集合的capacity
 9     private int capacity;
10     
11     
12     //重绕缓冲区-读取后操作指针回到0位置—针对多线程读取的时候，position位置改变。
13     public final Buffer rewind()
14     //重置缓冲区——position回到上一个mark点，mark回到-1
15     //类似于回滚到指定位置
16     public final Buffer reset()
17     //清除缓冲区——position回到0，mark回到-1，limit回到capacity
18     //一般用在读取后，清空缓冲区（缓冲区数据还在，只是操作指针归零了）
19     public final Buffer clear()
20     //翻转缓冲区——limit来到position,positio回到0，mark回到-1
21     //一般用在read（）方法前
22     public final Buffer flip()

 

　　接下来上代码—客户端：

 1 public class Client {
 2     public static void main(String[] args) throws IOException, InterruptedException {
 3         //创建客户端的通道
 4         SocketChannel sc = SocketChannel.open();
 5         //设置为非阻塞
 6         sc.configureBlocking(false);
 7         Socket s;
 8         //发起连接
 9         //连接过程在BIO中会产生阻塞
10         sc.connect(new InetSocketAddress("localhost", 60253));
11         //判断连接是否建立
12         while (!sc.isConnected()) {
13             //如果没连上，试图再次连接
14             //如果连接多次依然失败，则意味着这个连接失败
15             //sc.finishConnect底层会自动计数，计数多次依然失败则抛出异常
16             sc.finishConnect();
17         }
18 
19         //发送数据
20         sc.write(ByteBuffer.wrap("hello server".getBytes()));
21 
22         //读数据
23         Thread.sleep(50);
24         FileChannel fc = new FileOutputStream(new File("D:\\FeiQ.exe")).getChannel();
25         ByteBuffer buffer = ByteBuffer.allocate(500);
26         int len = 0;
27         while ((len = sc.read(buffer)) > 0) {
28             System.out.println(len);
29             //
30             buffer.flip();
31             fc.write(buffer);
32             buffer.clear();
33             
34         }
35         //关流
36         sc.close();
37     }
38 }

　　服务器端代码

 1 public class Server {
 2     public static void main(String[] args) throws IOException {
 3         
 4         /**选择器要求通道必须是非阻塞的*/
 5         
 6         //开启服务器端的通道
 7         ServerSocketChannel ssc = ServerSocketChannel.open();        
 8         //绑定
 9         ssc.bind(new InetSocketAddress(60253));        
10         //开启选择器
11         Selector selc = Selector.open();        
12         //将服务器注册到选择器上
13         ssc.configureBlocking(false);
14         ssc.register(selc, SelectionKey.OP_ACCEPT);        
15         //
16         while(true){
17             //进行选择
18             selc.select();
19             //获取选择出来的事件
20             Set<SelectionKey> set = selc.selectedKeys();
21             //遍历集合，根据事件类型不同，进行处理
22             Iterator< SelectionKey> it = set.iterator();
23             while (it.hasNext()) {
24                 SelectionKey key = it.next();
25                 
26                 //可接受
27                 if (key.isAcceptable()) {
28                     //真正需要处理的事件，需要通道来完成
29                     //从这个事件中需要获取到需要进行accept的通道
30                     ServerSocketChannel sscx =  (ServerSocketChannel) key.channel();
31                     //接受连接
32                     SocketChannel sc = sscx.accept();
33                     //需要给这个通道注册可读或者可写事件
34                     //如果需要注册可读，也主要注册可写——在注册的时候，后注册的事件会覆盖之前的事件 -或者|
35                     //将sc设置为非阻塞
36                     sc.configureBlocking(false);
37                     sc.register(selc, SelectionKey.OP_WRITE + SelectionKey.OP_READ);
38                 }                
39                 //可读
40                 if (key.isReadable()) {
41                     //先从事件中获取通道
42                     SocketChannel sc = (SocketChannel) key.channel();
43                     System.out.println("11111");
44                     //读取数据
45                     ByteBuffer dst = ByteBuffer.allocate(1024);
46                     sc.read(dst);
47                     dst.flip();
48                     System.out.println(new String(dst.array(), 0, dst.limit()));
49                     
50                     //注销read事件 +或者^
51                     sc.register(selc, key.interestOps() ^ SelectionKey.OP_READ);
52                 }                
53                 //可写
54                 if (key.isWritable()) {
55                     //先从事件中获取通道
56                     SocketChannel sc = (SocketChannel) key.channel();
57                     
58                     //写入事件
59                     //sc.write(ByteBuffer.wrap("hello client".getBytes()));
60                     FileChannel fc = FileTrans.getFileChannel();
61                     
62                     long len = fc.size();
63                     int postion = 0;
64                     while (postion < len) {
65                         long readlen = fc.transferTo(postion, fc.size(), sc);
66                         postion += readlen;
67                         
68                     }
69                     System.out.println(fc.size());
70                     
71                     //注销掉writer
72                     sc.register(selc, key.interestOps() ^ SelectionKey.OP_WRITE);
73                 }
74                 it.remove();
75             }
76         }
77     }
78 }
79 
80 class FileTrans{
81     public static FileChannel getFileChannel() throws FileNotFoundException{
82         FileInputStream fos = new FileInputStream(new File("E:\\FeiQ.exe"));
83         return fos.getChannel();    
84     }
85 }

　　代码功能很简单，1.服务器采用选择网络模型，开启后一直while循环，监听客户端连接，每有一个客户端连接过来，就向他发送一个文件；2.客户端连接上客户端后，先向客户端发送一个Hello Server，然后就开始接收服务器端发送过来的文件，边接收，边存储到本地。

　　在服务器端，核心代码如下：transferTo是零拷贝的，效率极高。

　　

 

 　　在客户端，核心代码如下：transFrom在知道文件大小的情况下，可以使用，这样可以实现零拷贝，效率高。ByteBuffer应该不是零拷贝，需要核实下。

　　

 

　　以上，本文内容结束了。

　　今天用NIO作了网络传输文件的最简单版本，实现了零拷贝发送文件，梳理了基本流程，深入挖掘下次在进行。。。