java nio 常见的nio类, nio 写文件方法, nio 比io 的优势

最新推荐文章于 2024-08-06 15:00:16 发布
最新推荐文章于 2024-08-06 15:00:16 发布
阅读量3.7k 收藏 1
点赞数 2
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nx188/article/details/51753613
版权

1..nio是同步非阻塞的意思, 以前的IO 都是阻塞IO, nio是非阻塞IO

2..阻塞非阻塞意思就是,  阻塞是线程一直等,  非阻塞是线程不等.   非阻塞就是来连接我不创建线程, 直到你来IO数据的请求, 即http 包, 我才创建线程, 如代码aaa处  

    int n = selector.select( ) 就是同步非阻塞的意思 , n代表IO请求的数量, 你来请求之前,我可以做我的事, 不是阻塞等, 你来请求之后即n>0, 我也照样可以做自己的事,

    爱什么时候处理IO就什么时候处理IO     即非阻塞就是你来IO我才创建线程去处理

nio 代码如下:

package NIO;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.FileChannel;
import java.nio.channels.Pipe;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.util.Date;
import java.util.Iterator;
/**
 * 
 * NIO (2) Chanel,chanel 就是通道,ByteBuffer俗称缓冲器,ByteBuffer 底层用byte[]数组存储实现的
 * 以下函数注释中括号的数字对应如下链接中的章节,参考:http://ifeve.com/file-channel/
 * 
 * NIO 和IO 的区别:
 * nio 快,io 慢.(13)unBlockReadTest()函数
 * nio 不阻塞, io阻塞, 未看出
 * nio 可以从文件的指定位置读/写, io做不到  (14)updateFile()函数
 * 
 * @author jaloli
 * 
 */

public class FileChanelTest {
	//(2,3)
	public static void writeAndReadChanel() throws IOException {  //write buffer,read buffer
		RandomAccessFile aFile = new RandomAccessFile("nio-data.txt", "rw");
		FileChannel inChannel = aFile.getChannel();
		ByteBuffer buf = ByteBuffer.allocate(48);
		int bytesRead = inChannel.read(buf);
		while (bytesRead != -1) {
			System.out.println("Read " + bytesRead);
			buf.flip();//翻转缓冲，使其由能写变成能读
			System.out.println("初始　position　：" +buf.position() + " limit : " + buf.limit() );
			while(buf.hasRemaining()){
				System.out.print( buf.position() + ":" + (char) buf.get() + " ");
			}
			buf.clear();
			bytesRead = inChannel.read(buf);
			System.out.println("\nRead " + bytesRead);
		}
		aFile.close();
	}
	//(4)分散（scatter）从Channel中读取是指在读操作时将读取的数据写入多个buffer中
	//聚集（gather）写入Channel是指在写操作时将多个buffer的数据写入同一个Channel
	public static void writeFileChanel() throws IOException {  //write chanel
		RandomAccessFile aFile = new RandomAccessFile("nio-data1.txt", "rw");
		FileChannel inChannel = aFile.getChannel();
		ByteBuffer body = ByteBuffer.allocate(6);
		ByteBuffer header = ByteBuffer.allocate(120000000);
		header.put(new byte[]{65,66,67,68,69,70});
		body.put(new byte[]{71,72,73,74,75,76});
		header.flip();
		body.flip();
//		System.out.println(header.getChar());
		ByteBuffer[] bufferArray = {header,body};//这里就是读buffer
		inChannel.write(bufferArray);
		aFile.close();
	}
	
	//(12)非阻塞测试, 如151行注释, 非block 并未发生,存疑
	public static void unBlockWriteTest() throws IOException {  //write chanel
		RandomAccessFile aFile = new RandomAccessFile("nio-data1.txt", "rw");
		FileChannel inChannel = aFile.getChannel();
		ByteBuffer body = ByteBuffer.allocate(6);
		ByteBuffer header = ByteBuffer.allocate(120000000);
		byte[] needWriteByte = new byte[10000000];
		byte[] needWriteByte1 = new byte[10000000];
		byte[] needWriteByte2 = new byte[10000000];
		byte[] needWriteByte3 = new byte[10000000];
		byte[] needWriteByte4 = new byte[10000000];
		byte[] needWriteByte5 = new byte[10000000];
		byte[] needWriteByte6 = new byte[10000000];
		byte[] needWriteByte7 = new byte[10000000];
		byte[] needWriteByte8 = new byte[10000000];
		byte[] needWriteByte9 = new byte[10000000];
		byte[] needWriteByte10 = new byte[10000000];
		byte[] needWriteByte11 = new byte[10000000];
		for(int i=0;i<10000000;i++){//10000000
			needWriteByte[i] = 1;
			needWriteByte1[i] = 1;
			needWriteByte2[i] = 1;
			needWriteByte3[i] = 1;
			needWriteByte4[i] = 1;
			needWriteByte5[i] = 1;
			needWriteByte6[i] = 1;
			needWriteByte7[i] = 1;
			needWriteByte8[i] = 1;
			needWriteByte9[i] = 1;
			needWriteByte10[i] = 1;
			needWriteByte11[i] = 1;
		}
		header.put(needWriteByte);
		header.put(needWriteByte1);
		header.put(needWriteByte2);
		header.put(needWriteByte3);
		header.put(needWriteByte4);
		header.put(needWriteByte5);
		header.put(needWriteByte6);
		header.put(needWriteByte7);
		header.put(needWriteByte8);
		header.put(needWriteByte9);
		header.put(needWriteByte10);
		header.put(needWriteByte11);
		body.put(new byte[]{71,72,73,74,75,76});//
		header.flip();
		body.flip();
		ByteBuffer[] bufferArray = {header,body};//   这里就是读buffer
		inChannel.write(bufferArray); //  这个会写117M的文件, 这个写的时候,卡住一下,写好后,再继续走下面的代码
		System.out.println("gggggggggggggggggggg");
		aFile.close();
	}
	
	//(13)nio 非阻塞读, 没看出来,但是看出来 nio 性能优于io
	public static void unBlockReadTest() throws IOException {  //write chanel
		RandomAccessFile aFile = new RandomAccessFile("nio-data1.txt", "rw");
		FileChannel inChannel = aFile.getChannel();
		int _5M = 1024*1024*5;
		ByteBuffer dst = ByteBuffer.allocateDirect(1);//_5M
		Date date = new Date();
		System.out.println(String.valueOf(date.getTime()));
		for(int i=0;i<10000000;i++){
			inChannel.read(dst);//这个就是一直在读文件的dst 个字节
//			inChannel.position(3);
//			System.out.println(inChannel.position());//以上两句有效,但是对read()方法无作用
//			System.out.println(byteBufferToString(dst));
		}
		System.out.println(String.valueOf(date.getTime()));//以上读完耗时忽略,是因为NIO面向的是data chunks,而java.io基本上是面向byte
		
		FileInputStream fr = new FileInputStream("nio-data1.txt");
		BufferedInputStream bis = new BufferedInputStream(fr);
		byte[] bytes = new byte[_5M];
		System.out.println(String.valueOf(date.getTime()));
		for(int i=0;i<10000000;i++) {
			System.out.println(bis.read(bytes));
		}
		System.out.println(String.valueOf(date.getTime()));//java io 读完耗时特别长,原因就是链接http://justjavac.iteye.com/blog/1998207 说的io 用吸管吸os给的一盆水 
	}
	
	//(14)nio 可以从文件指定位置写, 从文件指定位置读, io 做不到
	public static void updateFile() throws IOException {
		RandomAccessFile aFile = new RandomAccessFile("nio-data1.txt", "rw");
		FileChannel inChannel = aFile.getChannel();
		ByteBuffer needInsert = ByteBuffer.allocate(216);
		ByteBuffer readIn = ByteBuffer.allocate(216);
		needInsert.put("好".getBytes());
		needInsert.flip();//如果不加这句则无论字母汉字都是出乱码,因为后面的不可预知的字符会以utf-8等编码去解析
		inChannel.write(needInsert,3);//文件指定位置插入,源文件是 gegbbbbbbbbbwqfewq, 文件插入指定位置插入字符后变为  geg好bbbbbbbbbwqfewq
		inChannel.read(readIn, 3);//从指定位置读       我bbbbbbwqfewq
		readIn.flip();
		System.out.println(byteBufferToString(readIn));
		aFile.close();
	}
	
	//(5)transferFrom / transferTo
	public static void transferFromTest() {
		
	}
	
	//(6)selector 不懂干啥的，  浏览器中输入localhost:30/fdg 可以一直打印对象.代码参考：http://www.cnblogs.com/gaotianle/p/3325451.html
	public static void selectorTest() throws IOException {
		int port = 30;
		ServerSocketChannel serverChannel = ServerSocketChannel.open();
		ServerSocket serverSocket = serverChannel.socket();
		Selector selector = Selector.open();
		serverSocket.bind(new InetSocketAddress(port));
		serverChannel.configureBlocking(false);
		serverChannel.register(selector, SelectionKey.OP_ACCEPT);// 第二个参数是四种事件。这样serverChannel
																	// 作为一个channel
																	// 就注册到selector
																	// 上了
		while (true) {//<strong>selector 负责监听channel上有无数据,监听到后,channel 去read()拿数据</strong>
			int n = selector.select();//这里就是同步非阻塞, 也就是nio同步非阻塞的意思所在aaa
			if (n == 0) {             //但是这里非阻塞虽然不用一直等IO请求, 但也在一直轮询, 所以比较耗费资源, 因此出现aio
				continue; // nothing to do,其实这里可以做别的事,即非阻塞, 做一定的事后, 可以再selector.select() 判断有无IO请求到来,而不是一来个连接,就创建线程等待IO.
			}
			Iterator it = selector.selectedKeys().iterator();
			while (it.hasNext()) {							//当然这里如果来了IO请求, 那么本例没创建线程,而是用当前线程去处理IO数据
				SelectionKey key = (SelectionKey) it.next();
				if (key.isAcceptable()) {
					ServerSocketChannel serverchanel = (ServerSocketChannel) key.channel();
					SocketChannel channel = serverchanel.accept();
					if (channel == null) {
						;// handle code, could happen
					}
					channel.configureBlocking(false);// selector.select
														// 来选择已经注册的多个通道之一
					channel.register(selector, SelectionKey.OP_READ);
				} else if (key.isReadable()) {
					SocketChannel channel = (SocketChannel) key.channel(); // 通过selector
																			// 的key
																			// 拿到channel
					ByteBuffer buffer = ByteBuffer.allocate(48);// channel
																// 的东西落到buffer
																// 里,进而转化成byte，转化成string
					int read = channel.read(buffer);
					byte[] data = buffer.array();
					String message = new String(data);
					System.out.println("接收到的消息是： " + message);
				} else if (key.isWritable()) {

				} else if (key.isConnectable()) {
					SelectableChannel chanel = key.channel();
					System.out.println(chanel.toString());
				}
				it.remove();
			}
		}
	}
	//ByteBuffer to String
	private static String byteBufferToString(ByteBuffer buf) {
		CharBuffer charBuffer = null;
		try{
			if(buf.position() != 0)
				buf.flip();   //flip() 函数是让  ByteBuffer 对象的position 变为0. 这里不flip()打不出来ByteBuffer 缓冲区的数据
			Charset charset = Charset.forName("UTF-8");
			CharsetDecoder decoder = charset.newDecoder();
			charBuffer = decoder.decode(buf);
			return charBuffer.toString();
		} catch(Exception ex) {
			ex.printStackTrace();
		}
		return null;
	}
	
	//(7)FileChannel
	public static void fileChannelTest() throws IOException{
		//FileChannel 读数据
		RandomAccessFile rFile = new RandomAccessFile("D:/xiecheng/EclipseWorkingspace/WorkspaceLearning/jsp_api/src/FileChannelReadTest.txt", "rw");
		FileChannel inChannel = rFile.getChannel();
		ByteBuffer buf = ByteBuffer.allocate(48);
		int bytesRead = inChannel.read(buf);
		String readFileContent = byteBufferToString(buf);
		System.out.println("读文件结果为: "+readFileContent);
		
		//FileChannel 写数据
		RandomAccessFile wFile = new RandomAccessFile("D:/xiecheng/EclipseWorkingspace/WorkspaceLearning/jsp_api/src/FileChannelWriteTest.txt", "rw");
		FileChannel outChannel = wFile.getChannel();
		String needWrite = "我被写入文件aaa";
		ByteBuffer needWriteBuf = ByteBuffer.allocate(48); 
		needWriteBuf.clear();
		needWriteBuf.put(needWrite.getBytes());
		needWriteBuf.flip();
		while(needWriteBuf.hasRemaining()) {
			outChannel.write(needWriteBuf);
		}
		System.out.println("写文件结果请看文件本身,写的内容是:"+needWrite);
	}
	
	//(8)SocketChannel如上面(6)  
	
	//(10)DatagramChannel实现UDP传输,使用如下两个函数,  参考http://www.cnblogs.com/bronte/articles/1966607.html
	public static void socketChannelServerTest() throws IOException{
		DatagramChannel channel = DatagramChannel.open();
		channel.socket().bind(new InetSocketAddress(9991));
		ByteBuffer buf = ByteBuffer.allocate(48);
		buf.clear();
		channel.receive(buf);
		String readFileContent = byteBufferToString(buf);
		System.out.println("SocketChannel 接收的结果为: "+readFileContent);
	}
	//这个客户端函数在另一个类中运行,方便查看客户端给服务端发的数据
	public static void socketChannelClientTest() throws IOException{
		DatagramChannel channel = DatagramChannel.open();
		String newData = "New String to write to file..." + System.currentTimeMillis();
		ByteBuffer buf = ByteBuffer.allocate(48);
		buf.clear();
		buf.put(newData.getBytes());
		buf.flip();
		int bytesSent = channel.send(buf, new InetSocketAddress(9991));

	}
	//(11)Pipe
	public static void pipeTest() throws IOException {
		//写
		Pipe pipe = Pipe.open();
		Pipe.SinkChannel sinkChannel = pipe.sink();
		String newData = "New String to write to file..." + System.currentTimeMillis();
		ByteBuffer needBeWriteBuf = ByteBuffer.allocate(48);//此时needBeWriteBuf 这个ByteBuffer 的limit 值是0
		needBeWriteBuf.clear();
		needBeWriteBuf.put(newData.getBytes());
		System.out.println("needBeWriteBuf 的postion 和 limit 分别是: "+needBeWriteBuf.position() +", "+ needBeWriteBuf.limit());
		needBeWriteBuf.flip(); //position 设置为0,即顶头,读写公用一个position
		while(needBeWriteBuf.hasRemaining()) { //这个一次可能写0个到多个,所以需要重复写
			int byteWriteNum = sinkChannel.write(needBeWriteBuf);//write 之后,needBeWriteBuf 的position 就变成了43
			System.out.println("往sinkChannel 写的数据字节数为:" + byteWriteNum + ", 写的数据为: " + newData);
		}
		//读
		Pipe.SourceChannel sourceChannel = pipe.source();
		ByteBuffer needReadToBuf = ByteBuffer.allocate(48);
		int byteReadNum = sourceChannel.read(needReadToBuf);
		System.out.println("read 之后, postion is : "+needReadToBuf.position());  //read 一次, position 变为43
		String sourceChannelContent = byteBufferToString(needReadToBuf);
		System.out.println("sourceChannel 接收的结果长度为: " + byteReadNum +", sourceChannel 接收的结果为: "+sourceChannelContent);
	}
	
	//ByteBuffer 缓冲区
	public static void byteBufferTest(){
		ByteBuffer needBeWriteBuf = ByteBuffer.allocate(48);
		needBeWriteBuf.clear();
		needBeWriteBuf.put("我".getBytes());
		needBeWriteBuf.put("我".getBytes());
		needBeWriteBuf.put("我".getBytes());
//		needBeWriteBuf.clear(); //buffer.clear()  缓冲区清空了
		needBeWriteBuf.put("你".getBytes()); //正常追加到缓冲区, 我我我你
		
		String sourceChannelContent = byteBufferToString(needBeWriteBuf);
		System.out.println("ByteBuffer 缓冲区内容是  is " + sourceChannelContent);
	}
	
	public static void main(String[] args) throws IOException {
//		writeAndReadChanel();
//		writeFileChanel();
//		selectorTest();
//		fileChannelTest();
//		socketChannelServerTest();
//		pipeTest();
//		byteBufferTest();
//		unBlockWriteTest();
//		unBlockReadTest();
		updateFile();
	}
}


nx188
关注
专栏目录
Java文件读写IO/NIO及性能比较详细代码及总结
08-28
Java文件读写IO/NIO及性能比较详细代码及总结 Java文件读写是Java编程中一个非常重要的方面，在各种项目中都需要对文件进行读写操作。Java提供了多种方式来实现文件读写，包括字节读写、字符读取、行读取等。以下是...
java IO流，NIO流文件读取写入
社会底层无业大学生
04-23 1372
IO流，NIO流 // 文件字节输入流 FileInputStream fileInputStream = new FileInputStream("文件路径 或 File对象"); // 字节输入缓冲流 BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream); // 对象输入流
实现高效的文件操作：使用NIO进行文件读写和复制
m0_75198698的博客
06-11 1794
通过使用NIO库提供的`Files`类和相关方法，可以方便地进行文件的读取、写入和复制操作。相比于传统的IO操作，NIO使用了基于通道和缓冲区的方式，可以提供更高的性能和效率。同时，NIO还提供了更多的文件操作功能，如文件移动、删除、重命名等，可根据实际需求进行选择和使用。在Java中，可以使用NIO（New IO）库进行高效的文件操作，包括文件读取、写入和复制等操作。NIO提供了一组用于文件操作的类和方法，可以显著提高文件操作的性能和效率。// 逐行读取文件内容。// 逐行写入文件内容。
Java NIO 概述
最新发布
二掌柜的博客
08-06 575
Java NIO（New IO 或 Non Blocking IO）是从Java 1.4版本开始引入的一个新的 IO API，可以替代标准的 Java IO API。NIO 支持面向缓冲区的、基于通道的 IO 操作。NIO 将以更加高效的方式进行文件的读写操作。Java NIO 由以下几个核心部分组成：ChannelsBuffersSelectors虽然 Java NIO 中除此之外还有很多类和组件，但 Channel，Buffer 和 Selector 构成了核心的 API。
Java NIO读写文件
AG.『Feng』的博客
07-01 1068
NIO读写文件
Java NIO 读取文件、写入文件、读取写入混合
wangjun5159的专栏
11-24 2万+
前言 Java NIO使用通道、缓冲来操作流，所以要深刻理解这些概念，尤其是，缓冲中的数据结构，当前位置、limit、容量 读取文件的样例代码 String pathname = "C:\\Users\\adew\\Desktop\\jd-gui.cfg"; FileInputStream fin; try { fin = new FileInputStream(new
java之NIO简介
热门推荐
花&败
03-14 3万+
一、NIO基本简介 NIO (New lO)也有人称之为java non-blocking lO是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java lO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO,传统的IO的read和write只能阻塞执行，线程在读写IO期间不能干其他事情，比如调用socket.read()时，如果服务器一直没有数据
JAVA IO-NIO 详解
04-24
Java的IO与NIO是程序与外部环境交互的基础，它们各自具有独特的优势和应用场景。传统IO适用于简单且低并发的场景，而NIO则更适合高并发、高性能的应用。通过深入理解Channel、Buffer和Selector等核心组件的工作原理...
Java NIO Path接口和Files类配合操作文件的实例
08-28
在Java NIO中，Path接口和Files类是两个非常核心的组件，它们提供了一系列方法来操作文件系统中的文件和目录。这篇文章将通过实例讲解如何使用Java NIO的Path接口和Files类来操作文件。 首先，我们需要了解什么是...
JavaNIO浅析IO模型Java开发Java经验技巧共1
11-22
虽然Java NIO带来了诸多优势，但也存在一些问题，如API复杂、学习曲线较陡峭，以及异常处理相对繁琐等。对于新手来说，可能需要更多时间去理解和掌握。 总结，Java NIO是一个强大的工具，它改变了Java处理I/O的方式...
nio.zip_NIO_NewIO_NIO.c_java NIO chm_java nio
09-23
在这个文档中，你可以找到关于Java NIO类库的详细说明，例如`FileChannel`用于文件操作，`SocketChannel`和`ServerSocketChannel`用于网络通信，`ByteBuffer`作为最常用的缓冲区类型，以及`Selector`的使用方法等。...
NIO介绍
qq_33923684的博客
02-18 4763
一、NIO介绍 1、定义 NIO（Non-blocking I/O ，在Java领域，也称为New I/O），是一种同步非阻塞的I/O模型，也是I/O多路复用的基础，已经被越来越多地应用到大型应用服务器，成为解决高并发与大量连接、I/O处理问题的有效方式。 2、概叙 NIO主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector。传统IO基于字节流和字符流进行操作，而NIO基于Channel和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入
java使用nio读写文件
congge
11-16 1万+
IO原理 最近在研究 JAVA NIO 的相关知识，学习NIO，就不能提到IO的原理和事项，必经NIO是基于IO进化而来 IO涉及到的底层的概念大致如下： 缓冲区操作。2) 内核空间与用户空间。3) 虚拟内存。4) 分页技术 一，虚拟存储器 虚拟存储器是硬件异常(缺页异常)、硬件地址翻译、主存、磁盘文件和内核软件的完美交互，它为每个进程提供了一个大的、一致的和私有的地址空间。 虚拟存储器的三大...
Java网络编程——NIO编程
weixin_62017112的博客
07-16 1951
JavaNIO全称javanon-blockingIO，是指JDK提供的新API。从JDK1.4开始，Java提供了一系列改进的输入/输出的新特性，被统称为NIO(即NewIO)，是同步非阻塞的.缓冲区（Buffer）缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个数组，该对象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel提供从网络读取数据的渠道，但是读取或写入的数据都必须经由Buffer.......
NIO深入剖析
weixin_46633487的博客
02-28 1452
第四章 JAVA NIO深入剖析 在讲解利用NIO实现通信架构之前，我们需要先来了解一下NIO的基本特点和使用。 4.1 Java NIO 基本介绍 Java NIO（New IO）也有人称之为 java non-blocking IO是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO,传
Java NIO 详解
qq_33807380的博客
11-14 5952
NIO 是 Java SE 1.4 引入的一组新的 I/O 相关的 API，它提供了非阻塞式 I/O、选择器、通道、缓冲区等新的概念和机制。相比与传统的 I/O 多出的 N 不是单纯的 New，更多的是代表了 Non-blocking 非阻塞，NIO具有更高的并发性、可扩展性以及更少的资源消耗等优点。
java-nio读写文件
随笔
08-29 1145
java-nio读写文件
java 使用NIO进行文件的读写
weixin_39802680的博客
04-04 4899
前言 在NIO中使用FileChannel 用于文件数据的读写 FileChannel方法 public int read(ByteBuffer dst) 从通道读取数据并放到缓冲区中,此操作也会移动 Buffer 中的position指针，不断往position中放数据，read完成后position指向limit。 public int write(ByteBuffer src) 把缓冲区的数据写到通道中,此操作也会不断移动Buffer中的position位置直到limit，读取到的数据就是positi
Java NIO，高效操作I/O流的必备技能
思考的陈
04-16 2593
是这样的，在NIO零拷贝出现之前，一个I/O操作会将同一份数据进行多次拷贝。可以看下图，一次I/O操作对数据进行了四次复制，同时来伴随两次内核态和用户态的上下文切换，众所周知上下文切换是很耗费性能的操作。
Java IO/NIO文件读写深度解析与性能比较
本文档深入探讨了Java中文件读写的基本操作，包括传统的I/O（Input/Output）方法和Non-blocking I/O (NIO) 的性能比较。对于长期从事Web开发的Java开发者来说，这些基础知识可能有所遗忘，但在项目维护和新功能开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值