编程语言
首页 > 编程语言> > 浅尝JavaNIO

浅尝JavaNIO

作者:互联网

本文将通过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作了网络传输文件的最简单版本,实现了零拷贝发送文件,梳理了基本流程,深入挖掘下次在进行。。。

 

标签:JavaNIO,abstract,throws,浅尝,IOException,ByteBuffer,sc,public
来源: https://www.cnblogs.com/Ellen-Eyes/p/11862022.html