Java NIO使用和总结

深碍√TFBOYSˉ_ 2022-07-15 06:19 214阅读 0赞

***Java NIO使用和总结***

**0.前言**

NIO即New IO，是在java io机制的基础上增加的内容。这篇主要学习和使用它的用法， 主要的学习来自并发编程网[http://ifeve.com/java-nio-all/][http_ifeve.com_java-nio-all]

**1.Channel(通道)**

Channel其实就是对流进行了改进，使得既可以读也可以写，而一般意义上的流通常是单向的，这就是Channel的产生。下面看一下它的用法：

/**1.通道基本用法
    	 * channel类型
    	 * FileChannel 文件中读写数据
    	 * DatagramChannel UDP中读写数据
    	 * SocketChannel TCP中读写数据
    	 * ServerSocketChannel 监听TCP连接信息
    	 */

public static void main(String[] args) throws Exception {
    		/*文件输入流*/
    		FileInputStream filInputStream = new FileInputStream(new File("channel1.txt"));
    		/*从中获取通道*/
    		FileChannel channel1 = filInputStream.getChannel();
    		/*分配48字节capacity的ByteBuffer*/
    		ByteBuffer ByteBuffer = ByteBuffer.allocate(6);
    		/*写模式初始*/
    //		System.out.println("Channel1.main()position:"+ByteBuffer.position());
    //		System.out.println("Channel1.main()limit:"+ByteBuffer.limit());
    //		System.out.println("Channel1.main()capacity:"+ByteBuffer.capacity());
    		/*把数据从channel中读取到ByteBuffer*/
    		int ByteRead = channel1.read(ByteBuffer);
    		while(-1 != ByteRead){
    			/*写模式结束*/
    //			System.out.println("Channel1.main()position:"+ByteBuffer.position());
    //			System.out.println("Channel1.main()limit:"+ByteBuffer.limit());
    //			System.out.println("Channel1.main()capacity:"+ByteBuffer.capacity());
    			
    			System.out.println("Channel1-ByteRead-wri:"+ByteRead);
    			/*反转buffer，其实就是从写模式切换到读模式，后面详述*/
    			ByteBuffer.flip();
    			/*读模式开始*/
    //			System.out.println("Channel1.main()position:"+ByteBuffer.position());
    //			System.out.println("Channel1.main()limit:"+ByteBuffer.limit());
    //			System.out.println("Channel1.main()capacity:"+ByteBuffer.capacity());
    			
    			while(ByteBuffer.hasRemaining()){
    				System.out.println("Channel1-ByteRead-get:"+ByteBuffer.get());
    			}
    			/*读模式结束*/
    //			System.out.println("Channel1.main()position:"+ByteBuffer.position());
    //			System.out.println("Channel1.main()limit:"+ByteBuffer.limit());
    //			System.out.println("Channel1.main()capacity:"+ByteBuffer.capacity());
    			ByteBuffer.clear();
    			ByteRead = channel1.read(ByteBuffer);
    		}
    	}

**2.Buffer**

之前我们对流进行操作时，通常会用一个byte或者一个byte数组来接受，但是我们需要更多的功能，比如记录读到哪一个位置，这个时候操作数组很难满足，所以就有了Buffer，下面看一下它的用法：

/**2.buffer基本用法
    	 * Buffer的capacity,position和limit
    	 * capacity:不管是读模式，还是写模式，都代表缓冲区的长度
    	 * limit：
    	 * 在写模式下，limit其实就是capacity
    	 * 在读模式下，limit代表已经写入元素的数量
    	 * position:
    	 * 在写模式下，从零开始不管增加，最大值是capacity，position的值就代表已经写入的数据数量
    	 * 在读模式下，也是从零开始，按照写入的顺序把数据读取出来，最大值是limit，position的值就代表已经读取的数据数量
    	 */

![Center][]

上图的箭头方法分别表示数据的写入和读取的方向。写模式下，position从上往下，读模式下，position也是从上往下。  实际上就是position原本指向3，变成读模式后，就指向1了，如何测试buffer的位置，以及limit和capacity，只要把上面代码的注释去掉即可。 另外buffer还有一些其他的方法：

/**@Description
    	 * clear()和compact方法、
    	 * clear():如果调用的是clear()方法，position将被设回0，limit被设置成 capacity的值
    	 * compact():compact()方法将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素正后面。
    	 * limit属性依然像clear()方法一样，设置成capacity。现在Buffer准备好写数据了，但是不会覆盖未读的数据。
    	 */
    	
    	/**@Description
    	 * 此外，还有其他一些方法
    	 * mark(),rewind(),reset(),equals()和compareTo()方法
    	 */

**3.Scatter和Gather的思想**

/**3.Scatter/Gather(分散/聚集)
    	 *  Scattering Reads是指数据从一个channel读取到多个buffer中
    	 *  Gathering Writes是指数据从多个buffer写入到同一个channel
    	 */

![Center 1][]

看一下这种思想的用法：

public static void main(String[] args) throws Exception {
    		/*文件输入流*/
    		FileInputStream filInputStream = new FileInputStream(new File("channel1.txt"));
    		filInputStream.available();
    		/*从中获取通道*/
    		FileChannel channel1 = filInputStream.getChannel();
    		/*分配48字节capacity的ByteBuffer*/
    		ByteBuffer bufferHeader = ByteBuffer.allocate(8);
    		ByteBuffer bufferBody = ByteBuffer.allocate(8);
    		
    		ByteBuffer[] bufferArray = {bufferHeader,bufferBody};
    		/*把数据从channel中读取到ByteBuffer*/
    		channel1.read(bufferArray);
    		System.out.println("bufferHeader:"+bufferHeader);
    		System.out.println("bufferBody:"+bufferBody);
    		bufferHeader.flip();
    		while(bufferHeader.hasRemaining()){
    			System.out.println("Channel1.main():"+bufferHeader.get());
    		}
    		
    		ByteBuffer bufferHeader2 = ByteBuffer.allocate(8);
    		ByteBuffer bufferBody2 = ByteBuffer.allocate(8);
    		bufferHeader2.put("a".getBytes());
    		bufferBody2.put("b".getBytes());
    		/*注意切换成读模式，否则channel2中得不到正确的信息*/
    		bufferHeader2.flip();
    		bufferBody2.flip();
    		System.out.println("bufferHeader2:"+bufferHeader2);
    		System.out.println("bufferBody2:"+bufferBody2);
    		ByteBuffer[] bufferArray2 = {bufferHeader2,bufferBody2};
    		/*文件输入流*/
    		FileOutputStream fileOutputStream = new FileOutputStream(new File("channel2.txt"));
    		/*从中获取通道*/
    		FileChannel channel2 = fileOutputStream.getChannel();
    		channel2.write(bufferArray2);
    	}

**4.通道之间的数据传输**

/**4.通道之间数据传输
    	 * 在Java NIO中，如果两个通道中有一个是FileChannel，那你可以直接将数据
    	 * 从一个channel（译者注：channel中文常译作通道）传输到另外一个channel。
    	 * */

看一下它们的用法：

public static void main(String[] args) throws IOException {
    		/*测试transferFrom方法*/
    		RandomAccessFile fromFile = new RandomAccessFile("channel1.txt", "rw");
    		FileChannel      fromChannel = fromFile.getChannel();
    		RandomAccessFile toFile = new RandomAccessFile("channel2.txt", "rw");
    		FileChannel      toChannel = toFile.getChannel();
    		long position = 0;
    		long count = fromChannel.size();
    		toChannel.transferFrom(fromChannel, position,count);
    		System.out.println("Channel1.main()");
    	}

public static void main(String[] args) throws IOException {
    		/*测试transferTo方法*/
    		RandomAccessFile fromFile = new RandomAccessFile("channel1.txt", "rw");
    		FileChannel      fromChannel = fromFile.getChannel();
    		RandomAccessFile toFile = new RandomAccessFile("channel2.txt", "rw");
    		FileChannel      toChannel = toFile.getChannel();
    		long position = 0;
    		long count = fromChannel.size();
    		fromChannel.transferTo(position, count, toChannel);
    		System.out.println("Channel1.main()");
    	}

**5.关于几种流传输速度的比较**

传统的流在数据传输方面，可以设置自定义的数组大小，因为一个一个字节的传输肯定是最慢的；下面的测试数据大小为60M

1）数组大小为1024（通常应用中设置的值）时，传输测试：

public static void main(String[] args) throws IOException {
    
    		/*1.传统的输入输出流，一次读取1024字节*/
    		FileInputStream fileInputStream1 = new FileInputStream(new File("E:\\Majintao\\software1.rar"));
    		FileOutputStream fileOutputStream1 = new FileOutputStream(new File("E:\\Majintao\\software2.rar"));
    		Date dateFirst1 = new Date();
    		int readByte1 = 0;
    		byte[] byte1 = new byte[1024];
    		while(-1 != (readByte1 = fileInputStream1.read(byte1))){
    			fileOutputStream1.write(byte1,0,readByte1);
    		}
    		fileInputStream1.close();
    		fileOutputStream1.close();
    		Date dateLast1 = new Date();
    		Long timeDue1 = dateLast1.getTime()-dateFirst1.getTime();
    		System.out.println("传统流传输时间:"+timeDue1);
    	}

传统流传输时间:794

2）缓冲流，实际上是对流增加了一层缓冲，传输测试：

/*2.使用缓冲流来传输*/
    		FileInputStream fileInputStream2 = new FileInputStream(new File("E:\\Majintao\\software1.rar"));
    		FileOutputStream fileOutputStream2 = new FileOutputStream(new File("E:\\Majintao\\software3.rar"));
    		BufferedInputStream bufferedInputStream1 = new BufferedInputStream(fileInputStream2);
    		BufferedOutputStream bufferedOutputStream1 = new BufferedOutputStream(fileOutputStream2);
    		Date dateFirst2 = new Date();
    		int readByte2 = 0;
    		byte[] byte2 = new byte[1024];
    		while(-1 != (readByte2 = bufferedInputStream1.read(byte2))){
    			bufferedOutputStream1.write(byte2,0,readByte2);
    		}
    		bufferedInputStream1.close();
    		bufferedOutputStream1.close();
    		fileInputStream2.close();
    		fileOutputStream2.close();
    		Date dateLast2 = new Date();
    		Long timeDue2 = dateLast2.getTime()-dateFirst2.getTime();
    		System.out.println("缓冲流传输时间:"+timeDue2);

缓冲流传输时间:189

3）字符流，其实字符流本不应该参与这次的数据比较，因为它的优势是处理字符文件，这里还是把它拿出来测试，传输测试：

/*3.使用字符流*/
    		FileReader fileReader = new FileReader("E:\\Majintao\\software1.rar");
    		FileWriter fileWriter = new FileWriter("E:\\Majintao\\software4.rar");
    		Date dateFirst3 = new Date();
    		char[] char1 = new char[1024];
    		int readByte3 = 0;
    		while(-1 != (readByte3 = fileReader.read(char1))){
    			fileWriter.write(char1);
    		}
    		fileReader.close();
    		fileWriter.close();
    		Date dateLast3 = new Date();
    		Long timeDue3 = dateLast3.getTime()-dateFirst3.getTime();
    		System.out.println("字符流流传输时间:"+timeDue3);

字符流流传输时间:4516

4）自定义接受数组的大小，在使用传统流时，自定义最合适的数组大小，传输测试：

/*4.在上面1的例子上自定义缓冲数组的大小，调整为最合适的大小*/
    		FileInputStream fileInputStream4 = new FileInputStream(new File("E:\\Majintao\\software1.rar"));
    		FileOutputStream fileOutputStream4 = new FileOutputStream(new File("E:\\Majintao\\software5.rar"));
    		Date dateFirst4 = new Date();
    		int readByte4 = 0;
    		byte[] byte4 = new byte[204800];
    		while(-1 != (readByte4 = fileInputStream4.read(byte4))){
    			fileOutputStream4.write(byte4,0,readByte4);
    		}
    		fileInputStream4.close();
    		fileOutputStream4.close();
    		Date dateLast4 = new Date();
    		Long timeDue4 = dateLast4.getTime()-dateFirst4.getTime();
    		System.out.println("传统流传输时间(自定义缓冲数组大小):"+timeDue4);

传统流传输时间(自定义缓冲数组大小):77

5）使用filechannel的transferTo或者transferFrom方法（缺点是只能传输2G以下的数据），传输测试：

/*5.使用fileChannel*/
    		FileInputStream fileInputStream5 = new FileInputStream(new File("E:\\Majintao\\software1.rar"));
    		FileOutputStream fileOutputStream5 = new FileOutputStream(new File("E:\\Majintao\\software6.rar"));
    		FileChannel inFileChannel = fileInputStream5.getChannel();
    		FileChannel outFileChannel = fileOutputStream5.getChannel();
    		Date dateFirst5 = new Date();
    		inFileChannel.transferTo(0,inFileChannel.size(),outFileChannel);
    		fileInputStream5.close();
    		fileOutputStream5.close();
    		inFileChannel.close();
    		outFileChannel.close();
    		Date dateLast5 = new Date();
    		Long timeDue5 = dateLast5.getTime()-dateFirst5.getTime();
    		System.out.println("filechannel传输："+timeDue5);

filechannel传输：52

可以看到速度比自定义最合适的数组还要快

6）使用filechannel+buffer，传输测试：

/*6.使用fileChannel 通过buffer */
    		FileInputStream fileInputStream6 = new FileInputStream(new File("E:\\Majintao\\software1.rar"));
    		FileOutputStream fileOutputStream6 = new FileOutputStream(new File("E:\\Majintao\\software7.rar"));
    		Date dateFirst6 = new Date();
    		FileChannel inFileChannel6 = fileInputStream6.getChannel();
    		FileChannel outFileChannel6 = fileOutputStream6.getChannel();
    		
    		int readByte6 = 0;
    		ByteBuffer buffer = ByteBuffer.allocate(409600);
    		while(-1 != (readByte6 = inFileChannel6.read(buffer))){
    			buffer.flip();
    			outFileChannel6.write(buffer);
    			buffer.clear();
    		}
    		
    		fileInputStream6.close();
    		fileOutputStream6.close();
    		inFileChannel6.close();
    		outFileChannel6.close();
    		Date dateLast6 = new Date();
    		Long timeDue6 = dateLast6.getTime()-dateFirst6.getTime();
    		System.out.println("filechannel--buffer传输："+timeDue6);

filechannel--buffer传输：79

可以看到速度等同或者说略慢于自定义最合适数组

PS:来对几种传输做一个比较，同时还会引出两个问题：

/**
    	 *在速度的比较上 
    	 *最快的是transferFrom和transferTo方法(示例5)
    	 *然后是channel-buffer-channel(示例6)和自定义byte（示例4）
    	 *接着是缓冲流（示例2）
    	 *接着是（示例1），通常我们没有调整缓冲数组大小，直接设置为1024；
    	 *接着是字符流（示例3）
    	 *下面有两个问题
    	 *1）为什么channel会比较快
    	 *因为底层是C操作
    	 *2）在自定义缓冲数组时(示例4)，如何设置最合适的大小？为什么我们通常设置为1024
    	 *这个问题暂时不明白，后面研究时并且补充上；这里提供一个网上的答案：
    	 *每次文件读写是以簇为单位，每簇都要消耗时间，如果byte数大于一簇，肯定要多花时间。 不过现在电脑最小的簇也是4K，你的这两个对象没有差别。
    	 *如果你的io流是针对网络，那么就不是簇，而是一个包的大小。有些包的载量比1K小，可能会有些差别。
    	 */

**6.同步（阻塞）与异步（非阻塞）**

/**6.NIO中--------------关于同步(阻塞)，异步(非阻塞)，在数据读取和进程推进这两个方面的应用场景
    	 *由于非阻塞，所以线程可以做其他事情，但是这个读写需要监听，你当然可以设置一段时间就尝试读取一次，
    	 *但是现在系统中提供了监听的方法，selector； 并且由于理论上可以设置监听多个，因为多个channel同时
    	 *变为可读写的几率并不高，这样在一个线程中相比在多个线程中监听多个channel相比，减少了线程上下文
    	 *切换的开销。  select与非阻塞channel搭配更好，因为在监听到多个channel就绪时，在处理过程中,可能在
    	 *其中一个channel中阻塞,所以这也说明了NIO适合用在"多而小"的情况下，"多"指的是连接数据多，"小"指的
    	 *是一次传输的数据量小。
    	 *与Selector一起使用时，Channel必须处于非阻塞模式下。这意味着不能将FileChannel与Selector一起使用，
    	 *因为FileChannel不能切换到非阻塞模式，而套接字通道都可以，意思就是Selector适用于网络编程，后面再讲
    	 */

**7.channel方法拾遗**

/**7.channel方法拾遗
    	 * close()方法
    	 * position()方法，获得(设置)当前位置
    	 * size()方法 返回所关联文件的大小
    	 * truncate()方法 截取一个文件
    	 */

**8.Pipe 管道**

/**8.pipe()操作,用于在线程间数据传输
    	 * 多线程管道 是单向的
    	 * sinkChannel 数据写入其中
    	 * sourceChannel 从中读取数据
    	 * 设置完成sinkChannel和sourceChannel之后开启多线程的操作  
    	 */

使用示例如下，其中channel1.txt内容为：12345678

public static void main(String[] args) throws IOException {
    		Pipe pipe = Pipe.open();
    		SinkChannel sinkChannel = pipe.sink();
    		Pipe.SourceChannel sourceChannel = pipe.source();
    		
    		Thread thread1 = new Thread(new Runnable() {
    			public void run() {
    				/*文件输入流*/
    				try {
    					FileInputStream filInputStream = null;
    					filInputStream = new FileInputStream(new File("channel1.txt"));
    					/*从中获取通道*/
    					FileChannel channel1 = filInputStream.getChannel();
    					ByteBuffer buf = ByteBuffer.allocate(8);
    					buf.clear();
    					channel1.read(buf);
    					buf.flip();
    					while(buf.hasRemaining()) {
    						sinkChannel.write(buf);
    					}
    				} catch (FileNotFoundException e) {
    					e.printStackTrace();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    				System.out.println("Channel1.main(...).new Runnable() {...}.run()");
    			}
    		});
    		Thread thread2 = new Thread(new Runnable() {
    			public void run() {
    				ByteBuffer buf = ByteBuffer.allocate(8);
    				try {
    					int bytesRead = sourceChannel.read(buf);
    					buf.flip();
    					while(buf.hasRemaining()){
    						System.out.println("Channel1.main():"+buf.get());
    					}
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    				}
    			});
    		thread1.start();
    		thread2.start();
    	}

结果如下：

Channel1.main(...).new Runnable() {...}.run()
    Channel1.main():49
    Channel1.main():50
    Channel1.main():51
    Channel1.main():52
    Channel1.main():53
    Channel1.main():54
    Channel1.main():55
    Channel1.main():56

打印的结果就是12345678的ASCII码

**9.NIO和IO总结**

/**9.NIO相对IO的特点
    	 * IO             NIO
    	 * 面向流         面向缓冲(Buffer)
    	 * 阻塞IO         非阻塞IO(Channel)
    	 * 无			  选择器(Selector)
    	 * 
    	 * buffer的设计不仅仅是对原有的缓冲的封装，同时还支持了非阻塞IO(channel)，为什么这么说：
    	 * 每次读写操作都先把数据放到Buffer里面，然后多次调用Channel的写方法对数据进
    	 * 行操作，依靠对Buffer的大小来判断数据的完整性，如果是读方法，则根据read的返回值int判断
    	 */

**总结：**学习和使用了channel的基本用法， 主要是注意它的一些特点，从而合适的应用场景中想到它，不必详记它的语法~  IO的内容有很多，从来没有系统学习过，后面准备复习和总结下IO的用法。

[http_ifeve.com_java-nio-all]: http://ifeve.com/java-nio-all/
[Center]: /images/20220715/579ef37ede544a4dbb73ae91a615d58d.png
[Center 1]: /images/20220715/fe13caae6de74576b52d3cc3429e62bb.png