Java NIO使用和总结

最新推荐文章于 2024-05-18 11:05:43 发布

Jintao_Ma

最新推荐文章于 2024-05-18 11:05:43 发布

阅读量1.3k

点赞数 1

分类专栏： Java并发文章标签： NIO Channel Buffer NIO与IO 传输速度比较

本文链接：https://blog.csdn.net/Jintao_Ma/article/details/53047298

版权

Java并发专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java NIO使用和总结

0.前言

NIO即New IO，是在java io机制的基础上增加的内容。这篇主要学习和使用它的用法，主要的学习来自并发编程网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的值就代表已经读取的数据数量
	 */

上图的箭头方法分别表示数据的写入和读取的方向。写模式下，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
	 */

看一下这种思想的用法：

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的用法。

Jintao_Ma

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java NIO使用和总结

0.前言NIO即New IO，是在java io机制的基础上增加的内容。这篇主要学习和使用它的用法，主要的学习来自并发编程网 http://ifeve.com/java-nio-all/1.Channel(通道)Channel其实就是对流进行了改进，使得既可以读也可以写，而一般意义上的流通常是单向的，这就是Channel的产生。下面看一下它的用法： /**1.通道基本用法
复制链接

扫一扫