NIO

最新推荐文章于 2024-07-25 22:50:26 发布
最新推荐文章于 2024-07-25 22:50:26 发布
阅读量129 收藏
点赞数
分类专栏： 基础增强 文章标签： NIO

由于FileChannel 无法设置为非阻塞模式，该NIO主要用于网络编程，即C/S模式
NIo、Bio、aio、 的原理及区别与应用场景
https://blog.csdn.net/u013851082/article/details/53942947?utm_source=blogxgwz0
https://blog.csdn.net/caohongshuang/article/details/79455391
TCP/UDP 协议，和 HTTP、FTP、SMTP，区别及应用场景
https://www.cnblogs.com/duanxz/p/5127561.html

一、缓冲区（Buffer）：在 Java NIO 中负责数据的存取。缓冲区就是数组。用于存储不同数据类型的数据

根据数据类型不同（boolean 除外），提供了相应类型的缓冲区：
ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer

上述缓冲区的管理方式几乎一致，通过 allocate() 获取缓冲区

二、缓冲区存取数据的两个核心方法：
put() : 存入数据到缓冲区中
get() : 获取缓冲区中的数据

三、缓冲区中的四个核心属性：
capacity : 容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变。
limit : 界限，表示缓冲区中可以操作数据的大小。（limit 后数据不能进行读写）
position : 位置，表示缓冲区中正在操作数据的位置。

mark : 标记，表示记录当前 position 的位置。可以通过 reset() 恢复到 mark 的位置

0 <= mark <= position <= limit <= capacity

四、直接缓冲区与非直接缓冲区：
非直接缓冲区：通过 allocate() 方法分配缓冲区，将缓冲区建立在 JVM 的内存中 在堆中的数组
直接缓冲区：通过 allocateDirect() 方法分配直接缓冲区，将缓冲区建立在物理内存中。可以提高效率

@Test
	public void test2(){
		String str = "abcde";
		
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		buf.put(str.getBytes());
		
		buf.flip();
		
		byte[] dst = new byte[buf.limit()];
		buf.get(dst, 0, 2);
		System.out.println(new String(dst, 0, 2));
		System.out.println(buf.position());
		
		//mark() : 标记
		buf.mark();
		//get的数据在dst里
		buf.get(dst, 2, 2);
		System.out.println(new String(dst, 2, 2));
		System.out.println(buf.position());
		
		//reset() : 恢复到 mark 的位置
		buf.reset();
		System.out.println(buf.position());
		
		//判断缓冲区中是否还有剩余数据
		if(buf.hasRemaining()){
			
			//获取缓冲区中可以操作的数量
			System.out.println(buf.remaining());
		}
	}
	
	@Test
	public void test1(){
		String str = "abcde";
		
		//1. 分配一个指定大小的缓冲区
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		System.out.println("-----------------allocate()----------------");
		System.out.println(buf.position());
		System.out.println(buf.limit());
		System.out.println(buf.capacity());
		
		//2. 利用 put() 存入数据到缓冲区中
		buf.put(str.getBytes());
		
		System.out.println("-----------------put()----------------");
		System.out.println(buf.position());//位置移动
		System.out.println(buf.limit());//limit 、capacity大小不变
		System.out.println(buf.capacity());
		
		//3. 切换读取数据模式 
		buf.flip();
		
		System.out.println("-----------------flip()----------------");
		System.out.println(buf.position());//位置变回了0
		System.out.println(buf.limit());//limit 变为5
		System.out.println(buf.capacity());//不变
		
		//4. 利用 get() 读取缓冲区中的数据
		byte[] dst = new byte[buf.limit()];
		buf.get(dst);
		System.out.println(new String(dst, 0, dst.length));
		
		System.out.println("-----------------get()----------------");
		System.out.println(buf.position());//5
		System.out.println(buf.limit());//5
		System.out.println(buf.capacity());
		
		//5. rewind() : 可重复读
		buf.rewind();
		
		System.out.println("-----------------rewind()----------------");
		System.out.println(buf.position());//0
		System.out.println(buf.limit());//5
		System.out.println(buf.capacity());
		
		//6. clear() : 清空缓冲区. 但是缓冲区中的数据依然存在，但是处于“被遗忘”状态
		buf.clear();
		
		System.out.println("-----------------clear()----------------");
		System.out.println(buf.position());
		System.out.println(buf.limit());
		System.out.println(buf.capacity());
		
		System.out.println((char)buf.get());
		
	}

一、通道（Channel）：用于源节点与目标节点的连接。在 Java NIO 中负责缓冲区中数据的传输。Channel 本身不存储数据，因此需要配合缓冲区进行传输。

二、通道的主要实现类
java.nio.channels.Channel 接口：
|–FileChannel 无法设置为非阻塞模式
|–SocketChannel
|–ServerSocketChannel
|–DatagramChannel

三、获取通道

  1. Java 针对支持通道的类提供了 getChannel() 方法
    本地 IO：
    FileInputStream/FileOutputStream
    RandomAccessFile

    网络IO：
    Socket
    ServerSocket
    DatagramSocket

  2. 在 JDK 1.7 中的 NIO.2 针对各个通道提供了静态方法 open()

  3. 在 JDK 1.7 中的 NIO.2 的 Files 工具类的 newByteChannel()

四、通道之间的数据传输
transferFrom()
transferTo()

五、分散(Scatter)与聚集(Gather)
分散读取（Scattering Reads）：将通道中的数据分散到多个缓冲区中
聚集写入（Gathering Writes）：将多个缓冲区中的数据聚集到通道中

六、字符集：Charset
编码：字符串 -> 字节数组
解码：字节数组 -> 字符串

fis = new FileInputStream("d:/1.mkv");
			fos = new FileOutputStream("d:/2.mkv");
			
			inChannel = fis.getChannel();
			outChannel = fos.getChannel();
			
			//②分配指定大小的缓冲区
			ByteBuffer buf = ByteBuffer.allocate(1024);
			
			//③将通道中的数据存入缓冲区中
			while(inChannel.read(buf) != -1){
				buf.flip(); //切换读取数据的模式
				//④将缓冲区中的数据写入通道中
				outChannel.write(buf);
				buf.clear(); //清空缓冲区
			}

// open 方式得到通道
		FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
		FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);

//		inChannel.transferTo(0, inChannel.size(), outChannel);
		outChannel.transferFrom(inChannel, 0, inChannel.size());

public void test6() throws IOException{
		Charset cs1 = Charset.forName("GBK");
		
		//获取编码器
		CharsetEncoder ce = cs1.newEncoder();
		
		//获取解码器
		CharsetDecoder cd = cs1.newDecoder();
		
		CharBuffer cBuf = CharBuffer.allocate(1024);
		cBuf.put("尚硅谷威武！");
		cBuf.flip();
		
		//编码
		ByteBuffer bBuf = ce.encode(cBuf);
		
		for (int i = 0; i < 12; i++) {
			System.out.println(bBuf.get());
		}
		
		//解码
		bBuf.flip();
		CharBuffer cBuf2 = cd.decode(bBuf);
		System.out.println(cBuf2.toString());
		
		System.out.println("------------------------------------------------------");
		
		Charset cs2 = Charset.forName("UTF-8");
		bBuf.flip();
		CharBuffer cBuf3 = cs2.decode(bBuf);
		System.out.println(cBuf3.toString());
	}

一、使用 NIO 完成网络通信的三个核心：

  1. 通道（Channel）：负责连接

java.nio.channels.Channel 接口：
|–SelectableChannel
|–SocketChannel
|–ServerSocketChannel
|–DatagramChannel
|–Pipe.SinkChannel
|–Pipe.SourceChannel

  1. 缓冲区（Buffer）：负责数据的存取

  2. 选择器（Selector）：是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况

//客户端
	@Test
	public void client() throws IOException{
		//1. 获取通道
		SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
		
		//2. 切换非阻塞模式
		sChannel.configureBlocking(false);
		
		//3. 分配指定大小的缓冲区
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		//4. 发送数据给服务端
		Scanner scan = new Scanner(System.in);
		
		while(scan.hasNext()){
			String str = scan.next();
			buf.put((new Date().toString() + "\n" + str).getBytes());
			buf.flip();
			sChannel.write(buf);
			buf.clear();
		}
		
		//5. 关闭通道
		sChannel.close();
	}

	//服务端
	@Test
	public void server() throws IOException{
		//1. 获取通道
		ServerSocketChannel ssChannel = ServerSocketChannel.open();
		
		//2. 切换非阻塞模式
		ssChannel.configureBlocking(false);
		
		//3. 绑定连接
		ssChannel.bind(new InetSocketAddress(9898));
		
		//4. 获取选择器
		Selector selector = Selector.open();
		
		//5. 将通道注册到选择器上, 并且指定“监听接收事件”
		ssChannel.register(selector, SelectionKey.OP_ACCEPT);
		
		//6. 轮询式的获取选择器上已经“准备就绪”的事件
		while(selector.select() > 0){
			
			//7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
			
			while(it.hasNext()){
				//8. 获取准备“就绪”的是事件
				SelectionKey sk = it.next();
				
				//9. 判断具体是什么事件准备就绪
				if(sk.isAcceptable()){
					//10. 若“接收就绪”，获取客户端连接
					SocketChannel sChannel = ssChannel.accept();
					
					//11. 切换非阻塞模式
					sChannel.configureBlocking(false);
					
					//12. 将该通道注册到选择器上
					sChannel.register(selector, SelectionKey.OP_READ);
				}else if(sk.isReadable()){
					//13. 获取当前选择器上“读就绪”状态的通道
					SocketChannel sChannel = (SocketChannel) sk.channel();
					
					//14. 读取数据
					ByteBuffer buf = ByteBuffer.allocate(1024);
					
					int len = 0;
					while((len = sChannel.read(buf)) > 0 ){
						buf.flip();
						System.out.println(new String(buf.array(), 0, len));
						buf.clear();
					}
				}
				
				//15. 取消选择键 SelectionKey
				it.remove();
			}
		}
	}

pipe

@Test
	public void test1() throws IOException{
		//1. 获取管道
		Pipe pipe = Pipe.open();
		
		//2. 将缓冲区中的数据写入管道
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		Pipe.SinkChannel sinkChannel = pipe.sink();
		buf.put("通过单向管道发送数据".getBytes());
		buf.flip();
		sinkChannel.write(buf);
		
		//3. 读取缓冲区中的数据
		Pipe.SourceChannel sourceChannel = pipe.source();
		buf.flip();
		int len = sourceChannel.read(buf);
		System.out.println(new String(buf.array(), 0, len));
		
		sourceChannel.close();
		sinkChannel.close();
	}
JackLi_csdn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NIO概述
12-22
2.2 NIO概述 NIO NIO ==> New IO(新IO), Non-Block IO(非阻塞IO) NIO非阻塞IO，运行当前程序在处理IO事务时，不会影响其他程序的运行，可以在不使用多线程的情况下，满足IO操作要求。 三大核心部分: 通道 ...
Java流NIO
12-22
Java NIO，全称为New Input/Output，是Java平台中用于处理输入输出操作的重要部分，自Java 1.4版本引入。NIO的核心目标是提供一种更高效、更灵活的I/O模型，以应对高性能应用的需求。传统的Java IO API基于流(Stream...
NIO图文详解
qq_40439628的博客
07-12 1876
（1）阻塞I/O模型：阶段一和阶段二用户进程都处于阻塞状态，效率最低，适用于并发量低的小型网站，是java BIO的基础；（2）非阻塞I/O模型：阶段一用户进程处于非阻塞状态，但应用进程需不断轮询内核空间数据是否准备好，消耗大量CPU时间；阶段二用户进程处于非阻塞状态；（3）I/O复用模型：阶段一和阶段二用户进程都处于阻塞状态，但以较少的代价同时监听多个文件描述符，效率较高，适用于并发高的大中型网站，java NIO是实现I/O复用模型的基础；
什么是NIO
yuiezt的专栏
07-25 1379
NIO支持面向缓冲区的、基于通道的IO操作，其核心组件包括缓冲区（Buffer）、通道（Channel）和选择器（Selector）。NIO（New Input/Output）作为Java中一种新的IO处理方式，相较于传统的BIO（Blocking Input/Output）具有一系列的优点，但同时也存在一些潜在的缺点。
NIO简介
ntzzzsj的博客
07-20 1423
在1.4版本之前，JavaIO类库是阻塞式IO；从1.4版本开始，引进了新的异步IO库，被称为JavaNewIO类库，简称为JavaNIO。JavaNIO类库的目标，就是要让Java支持非阻塞IO，基于这个原因，更多的人喜欢称JavaNIO为非阻塞IO（Non-BlockIO），称“老的”阻塞式JavaIO为OIO（OldIO）。总体上说，NIO弥补了原来面向流的OIO同步阻塞的不足，它为标准Java代码提供了高速的、面向缓冲区的IO。Channel（通道）Buffer（缓冲区）...
NIO理解
C18298182575的博客
01-17 1375
基本概念理解 channel 轨道buffer火车selector 调度中心 1.buffer与channel之间相互读写 2.NIO本质： 不管是读还是写针对buffer操作，客户端与buffer交互，通过buffer实现非阻塞 3.之前BIO read客户端是否阻塞的，现在从buffer中读取是非阻塞的，用一个线程可以读取多个通道，哪个通道有数据过来（事件），能感知，即服务端多线程中每个线程处理多个通道，哪个通道有数据，处理哪个。 4.不是轮询，是Reactor模式，事件通知Selecto..
NIO-Selector详解
z2698751935的博客
01-27 1306
Selector选择器，也可以称为多路复⽤器。它是Java NIO的核⼼组件之⼀，⽤于检查⼀个或多个Channel的状态是否处于可读、可写、可连接、可接收等。通过⼀个Selector选择器管理多个Channel，可以实现⼀个线程管理多个Channel对应的⽹络连接。使⽤单线程管理多个Channel可以避免多线程的线程上下⽂切换带来的额外开销。
Java NIO 详解
qq_33807380的博客
11-14 5503
NIO 是 Java SE 1.4 引入的一组新的 I/O 相关的 API，它提供了非阻塞式 I/O、选择器、通道、缓冲区等新的概念和机制。相比与传统的 I/O 多出的 N 不是单纯的 New，更多的是代表了 Non-blocking 非阻塞，NIO具有更高的并发性、可扩展性以及更少的资源消耗等优点。
NIO与BIO
喵酱
04-07 776
NIO与BIO
IO与NIO区别
热门推荐
qq_17405183的博客
07-29 1万+
一、概念 NIO即New IO，这个库是在JDK1.4中才引入的。NIO和IO有相同的作用和目的，但实现方式不同，NIO主要用到的是块，所以NIO的效率要比IO高很多。在Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。 二、NIO和IO的主要区别 下表总结了Java IO和NIO之间的主要区别： 1.面向流与面向缓冲 Java IO和NIO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至
NIO模型讲解
修理男爵的博客
09-18 2735
BIO模型 同步阻塞，一个客户端连接对应一个处理线程。 缺点 代码会阻塞 线程数太多 应用场景 适用于连接数目比较小且固定的架构 NIO模型 同步非阻塞，一个线程可以处理多个请求连接。 多路复用器selector I/O多路复用底层使用的 linux的 api (select、poll、epoll)来实现。 三大核心组件：Channel（通道）、Buffer（缓冲区）、Selector（选择器） channel类似于流 ...
Java NIO 中文 Java NIO 中文 Java NIO 中文文档
07-15
Java NIO 深入探讨了 1.4 版的 I/O 新特性，并告诉您如何使用这些特性来极大地提升您所写的 Java 代码的执行效率。这本小册子就程序员所面临的有代表性的 I/O 问题作了详尽阐述，并讲解了 如何才能充分利用新的 I/O ...
nio的excel导出
06-07
nio的excel导出
niodemo.zip
05-26
Java NIO，全称为Non-Blocking Input/Output（非阻塞输入/输出），是Java标准库提供的一种替代传统I/O（BIO）模型的新技术。NIO在Java 1.4版本中引入，旨在提高I/O操作的效率，特别是在处理大量并发连接时。与传统的...
RK3576-Hardware-Design-Guide
08-21
包含datasheet
273教学质量评价系统.zip
08-21
摘 要 随着科学技术的飞速发展，社会的方方面面、各行各业都在努力与现代的先进技术接轨，通过科技手段来提高自身的优势，教学质量评价系统当然也不能排除在外。教学质量评价系统是以实际运用为开发背景，运用软件工程开发方法，采用jsp技术构建的一个管理系统。整个开发过程首先对软件系统进行需求分析，得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统总体结构设计、系统数据结构设计、系统功能设计和系统安全设计等；详细设计主要包括模块实现的关键代码，系统数据库访问和主要功能模块的具体实现等。最后对系统进行功能测试，并对测试结果进行分析总结，及时改进系统中存在的不足，为以后的系统维护提供了方便，也为今后开发类似系统提供了借鉴和帮助。 本教学质量评价系统采用的数据库是Mysql，使用JSP技术开发。在设计过程中，充分保证了系统代码的良好可读性、实用性、易扩展性、通用性、便于后期维护、操作方便以及页面简洁等特点。
基于Android手机点餐系统APP设计与实现.docx
08-21
基于Android手机点餐系统APP设计与实现
全国自学考试计算机网络管理试题.pdf
最新发布
08-21
浙江省的全国自学考试计算机网络管理试题，总共38道题，包含单选，填空，多选等等。
深入理解Java NIO
"Java NIO (中文版)" 是一本深入探讨Java NIO（非阻塞I/O）技术的书籍，作者Ron Hitchens详尽地介绍了NIO的基础和底层概念，如缓冲区、虚拟内存等，并提供了丰富的技术细节。 Java NIO（New Input/Output）是Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值