Java NIO 浅析

最新推荐文章于 2025-12-11 22:46:37 发布
原创 最新推荐文章于 2025-12-11 22:46:37 发布 · 142 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #操作系统

1. Java NIO初探

1.1 什么是IO

      I/O输入/输出(Input/Output),分为IO设备和IO接口两个部分。 在POSIX兼容的系统上，例如Linux系统，I/O操作可以有多种方式，比如DIO(Direct I/O),AIO(Asynchronous I/O 异步I/O),Memory-Mapped I/O(内存映设I/O)等，不同的I/O方式有不同的实现 方式和性能，在不同的应用中可以按情况选择不同的I/O方式。

      IO是主存和外部设备之间拷贝数据的过程。IO的实现是通过操作系统调用IO命令完成的。高级语言对这些IO命令加以封装形成IO api，应用程序通过调用这些api完成网络通信，文件存储，程序的输入输出等。

1.2 Java NIO

       Java NIO 是 Java New IO 的简称，实在jdk1.4版本之后提供的新的IO api。该api提供了无阻塞的io访问的实现方式。

       Sun 标榜的Java NIO特性如下：

        –     为所有的原始类型提供 (Buffer) 缓存支持。 

        –     字符集编码解码解决方案。

        –     Channel ：一个新的原始 I/O 抽象。

        –     支持锁和内存映射文件的文件访问接口。

        –     提供多路 (non-bloking) 非阻塞式的高伸缩性网络 I/O 。

 

1.3 Java NIO 实战

         a）现在实用JAVA NIO实现一个文本文件拷贝的过程。

         

package org.cookie.nio;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;

public class NIO {
	public static void main(String args[]) throws IOException {
		String filePathIn = "c:\\nio_test.sql";
		String filePathOut = "d:\\nio_test_n.txt";
		File fileOutN = new File("d:\\nio_test_nn.txt");
		File fileOut = new File(filePathOut);
		if (!fileOut.exists()) {
			fileOut.createNewFile();
		}
		if (!fileOutN.exists()) {
			fileOutN.createNewFile();
		}
		FileInputStream fileInputStream = new FileInputStream(filePathIn);
		FileOutputStream fileOutputStream = new FileOutputStream(filePathOut);

		FileOutputStream fileOutputStreamN = new FileOutputStream(fileOutN);

		
		FileChannel fileInputChannel = fileInputStream.getChannel(); //从文件流中拿到文件通道
		FileChannel fileOutputChannel = fileOutputStream.getChannel();
		FileChannel fileOutputChannelN = fileOutputStreamN.getChannel();

		ByteBuffer byteBuffer = ByteBuffer.allocate(1024);//建立一个缓存通道
		while (true) {
			byteBuffer.clear();//清空通道，byteBuffer变得可写
			int r = fileInputChannel.read(byteBuffer);//文件通道向byteBuffer读入数据
			if (r == -1) {
				break;
			}
			byteBuffer.flip();//环绕byteBuffer这时候可以将byteBuffer写入到文件通道中
			fileOutputChannel.write(byteBuffer);
			byteBuffer.flip();//byteBuffer通道可以实现重复读，在读之前需要调用byteBuffer的flip方法
			fileOutputChannelN.write(byteBuffer);
			byteBuffer.flip();
			System.out.println(byteBufferToString(byteBuffer));
		}
		fileInputStream.close();
		fileOutputStream.close();
		fileOutputStreamN.close();
	}

	public static String byteBufferToString(ByteBuffer buffer) {

		System.out.println("buffer=" + buffer);
		try {
			Charset charset = Charset.forName("UTF-8");//声明一个字符集
			CharBuffer charBuffer = charset.decode(buffer);//通过字符集对buffer进行编码
			System.out.println("charBuffer=" + charBuffer);
			System.out.println(charBuffer.toString());
			return charBuffer.toString();
		} catch (Exception ex) {
			ex.printStackTrace();
			return "";
		}
	}
}

 

       b) 通过 Java AIO实现一个简单的服务端，客户端通信

   JAVA NIO Server 端

    

package com.cookie.study.java;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.ClosedChannelException;
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.util.Iterator;


public class HeartServerNIO {
	public static String decode(ByteBuffer byteBuffer){
		Charset charset = Charset.forName("UTF-8");
		CharBuffer  charBuffer = charset.decode(byteBuffer);
		return charBuffer.toString();
	}
	
    public static void main(String args[]) 
    { 
        try {
			Selector selector = Selector.open();//创建一个selector对象，selector是在Java网络aio中最重要的对象
			
			ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();//建立一个ServerSocketChannel
			serverSocketChannel.configureBlocking(false);//设置ServerSocketChannel为非阻塞的方式
			InetSocketAddress address = new InetSocketAddress(9000);
			serverSocketChannel.socket().bind(address);
			
			//注册Selector，通过SelectionKey.OP_ACCEPT
			SelectionKey selectionKey = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
			
			
			while (true){
			    int selectedNum = selector.select();//Selects a set of keys whose corresponding channels are ready for I/O operations. 翻译为：选取一下已经准备好IO操作的通道的SelectionKey
			    System.out.println("Selected Number is :"+selectedNum);
			    Iterator iter = selector.selectedKeys().iterator();//迭代SelectionKeys
			    
			    while(iter.hasNext()){
			        SelectionKey selectedKey = (SelectionKey)iter.next();
			        
			        if ((selectedKey.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT){// 处理OP_ACCEPT事件
			            ServerSocketChannel serverChannel = (ServerSocketChannel)selectedKey.channel();
			            SocketChannel socketChannel = serverChannel.accept();
			            socketChannel.configureBlocking(false);
			            
			            SelectionKey readKey = socketChannel.register(selector, SelectionKey.OP_READ);//注册OP_READ事件                    
			            iter.remove();               
			        }else if ( (selectedKey.readyOps()&SelectionKey.OP_READ) == SelectionKey.OP_READ ){//处理OP_READ事件
			            ByteBuffer buffer = ByteBuffer.allocate(1024);
			            SocketChannel socketChannel = (SocketChannel)selectedKey.channel();
			            while (true){
			                buffer.clear();
			                int i=socketChannel.read(buffer);//将socket数据读入byteBuffer中
			            
			                if (i == -1) break;
			                if (i == 0) break;
			            
			                buffer.flip();//环绕byteBuffer，准备读取buffer数据
			                socketChannel.write(buffer);
			                buffer.flip();//需要再次读取时，需要再次调用buffer的环绕方法
			                System.out.println(decode(buffer));
			            }
			            iter.remove();
			        }
			    }
			}
		} catch (ClosedChannelException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
    }
}

   

 

    Java  NIO Client 端

   

package com.cookie.study.java;

import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class HeartClientNIO extends Frame {

	/* 标识数字 */
	private static int flag = 0;
	/* 缓冲区大小 */
	private static int BLOCK = 4096;
	/* 接受数据缓冲区 */
	private static ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);
	/* 发送数据缓冲区 */
	private static ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);
	/*
	 * 成员方法出场...
	 */
	private TextField tfText;
	private TextArea taContent;

	private TFListener tfListener = new TFListener();

	/**
	 * 注意，入口... ^^
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		new HeartClientNIO().launchFrame();
	}

	/**
	 * Loading GU
	 */
	public void launchFrame() {
		tfText = new TextField();
		taContent = new TextArea();
		this.setSize(300, 300);
		this.setLocation(300, 300);
		this.tfText.addActionListener(this.tfListener);
		this.add(tfText, BorderLayout.SOUTH);
		this.add(taContent, BorderLayout.NORTH);
		this.addWindowListener(new WindowAdapter() {
			@Override
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		this.pack();
		this.connect();
		this.setVisible(true);
	}

	/**
	 * 我在努力地连接服务器中...
	 */
	public void connect() {
		try {
			SocketChannel socketChannel = SocketChannel.open();
			socketChannel.configureBlocking(false);

			Selector selector = Selector.open();
			socketChannel.register(selector, SelectionKey.OP_CONNECT);
			InetSocketAddress inetSocketAddress = new InetSocketAddress(
					"localhost", 9000);
			socketChannel.connect(inetSocketAddress);

			this.tfListener.setSelector(selector);

			Set<SelectionKey> selectionKeys;
			Iterator<SelectionKey> iterator;
			SelectionKey selectionKey;
			SocketChannel client;
			String receiveText;
			String sendText;
			int count = 0;

			// 选择一组键，其相应的通道已为 I/O 操作准备就绪。
			// 此方法执行处于阻塞模式的选择操作。
			selector.select();
			// 返回此选择器的已选择键集。
			selectionKeys = selector.selectedKeys();
			System.out.println(selectionKeys.size());
			iterator = selectionKeys.iterator();
			while (iterator.hasNext()) {
				selectionKey = iterator.next();
				if (selectionKey.isConnectable()) {
					System.out.println("client connect");
					client = (SocketChannel) selectionKey.channel();
					// 判断此通道上是否正在进行连接操作。
					// 完成套接字通道的连接过程。
					if (client.isConnectionPending()) {
						client.finishConnect();
						System.out.println("完成连接!");
						sendbuffer.clear();
						sendbuffer.put("Hello,Server".getBytes("UTF-8"));
						sendbuffer.flip();
						client.write(sendbuffer);
					}
					client.register(selector, SelectionKey.OP_READ);
				}
			}
			selectionKeys.clear();
			new Thread(new ReadProcess(selector)).start();
			
		} catch (UnknownHostException e) {
			System.out.println("UnknownHostException");
			e.printStackTrace();
		} catch (IOException e) {
			System.out.println("IOException");
			e.printStackTrace();
		} finally {
			// 关闭啥尼...
		}

	}

	/**
	 * 额不会傻等着tfText(TextField tfText的监听器类)
	 */
	class TFListener implements ActionListener {
		private String str;
		private Selector selector;

		@Override
		public void actionPerformed(ActionEvent e) {
			str = tfText.getText().trim();
			tfText.setText("");

			try {
				if (selector != null) {
					selector.select();
					Set<SelectionKey> selectionKeys = selector.selectedKeys();
					Iterator<SelectionKey> iterator = selectionKeys.iterator();
					while (iterator.hasNext()) {
						SelectionKey selectionKey = iterator.next();
						if (selectionKey.isWritable()) {
							sendbuffer.clear();
							SocketChannel client = (SocketChannel) selectionKey.channel();
							String sendText = "message from client--" + (flag++)+str;
							sendbuffer.put(sendText.getBytes("UTF-8"));
							// 将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位
							sendbuffer.flip();
							client.write(sendbuffer);
							System.out.println("客户端向服务器端发送数据--：" + sendText);
							client.register(selector, SelectionKey.OP_READ);
						}
					}
					selectionKeys.clear();
				}
			} catch (ClosedChannelException e1) {
				e1.printStackTrace();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		}

		public void setSelector(Selector selector) {
			this.selector = selector;
		}
	}
	
	public class ReadProcess implements Runnable{
		
		private Selector selector;
		
		public ReadProcess(Selector selector){
			this.selector = selector;
		}
		
		public void run() {
			while(true){
				try {
					selector.select();
					Set<SelectionKey>  selectionKeys = this.selector.selectedKeys();
					Iterator<SelectionKey> iterator = selectionKeys.iterator();
					while(iterator.hasNext()){
						SelectionKey selectionKey = iterator.next();
						if(selectionKey.isReadable()){
							SocketChannel client = (SocketChannel) selectionKey.channel();
							// 将缓冲区清空以备下次读取
							receivebuffer.clear();
							// 读取服务器发送来的数据到缓冲区中
							int count = client.read(receivebuffer);
							if (count > 0) {
								String receiveText = new String(receivebuffer.array(), 0,
										count,"UTF-8");
								System.out.println("客户端接受服务器端数据--:" + receiveText);
								taContent.setText(taContent.getText()+"\n"+receiveText);
								client.register(selector, SelectionKey.OP_WRITE);
							}
						}
					}
					selectionKeys.clear();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

 

 

       

 

 

      

 

 

 

Java NIO浅析
Fong灵
03-14 1036
NIO、多路复用、IO
JavaNIO浅析IO模型Java开发Java经验技巧共1
11-22
Java NIO，全称为New Input/Output，是Java在1.4版本引入的一个新特性，为Java程序员提供了更高效的数据传输方式。与传统的IO模型相比，NIO具有非阻塞、多路复用等优点，尤其适用于高并发、低延迟的网络应用。本文将...
Java I/O与NIO实战练习：深入理解与应用
weixin_33562004的博客
07-06 961
Java中的IO（Input/Output）流是处理数据传输的一种机制。在Java编程中，流是一种信息的载体，允许程序以连续的方式读取或写入数据。IO流主要用于处理数据的输入和输出操作，包括文件读写、网络通信等。Java NIO（New Input/Output）是一种基于通道（Channel）和缓冲区（Buffer）的I/O操作方法，支持面向缓冲区的（Buffer-oriented）、基于通道的I/O操作。NIO与传统的IO的区别主要体现在以下几个方面：缓冲区与通道。
JAVA NIO浅析
u012133048的博客
09-21 266
JAVA NIO 本文算是把一些讲的比较清晰的帖子，拼凑了一番，修改了部分描述不准确的，以及个人觉得比较混淆的表达方式。补充了一些容易忽略的注意点，以及理解上的小心得。站在各位前辈的肩膀上，总是能走不少弯路。 主要参考的博客是：https://blog.youkuaiyun.com/hlx20080808/article/details/78053556 ...
java NIO浅析
taotao12312的博客
12-18 257
NIO与IO的主要区别是：1、IO多路复用 2、IO流与NIO缓冲区 阻塞与非阻塞（IO多路复用） 传统IO是阻塞的，当用户线程发出IO请求之后，内核会去查看数据是否就绪，如果没有就绪就会等待数据就绪，而用户线程就会处于阻塞状态，用户线程交出CPU。当数据就绪之后，内核会将数据拷贝到用户线程，并返回结果给用户线程，用户线程才解除block状态。此外由于每个连接都需要创建一个线程，...
Java NIO：浅析IO模型_动力节点Java学院整理
08-30
Java NIO：浅析IO模型 Java NIO是Java语言中用于高性能I/O操作的API，理解IO模型是学习Java NIO的基础。本文将从同步和异步的概念开始，然后介绍阻塞和非阻塞的区别，接着介绍阻塞IO和非阻塞IO的区别，最后介绍五种...
Java NIO：浅析I/O模型
12-22
在进入Java NIO编程之前，我们先来讨论一些比较基础的知识：I/O模型。下面本文先从同步和异步的概念 说起，然后接着阐述了阻塞和非阻塞的区别，接着介绍了阻塞IO和非阻塞IO的区别，然后介绍了同步IO和异步IO的区别，...
java nio 原理浅析
06-19
Java NIO（非阻塞I/O）是一种在Java中实现高效I/O操作的方式，相比于传统的BIO（阻塞I/O），NIO具有更好的性能和更低的资源消耗，特别是在高并发和大数据传输的场景下。Netty是基于Java NIO的一个高性能、异步事件...
Java SE——12.异常（≠错误）《干货笔记》
要努力去发光，而不是被照亮~
12-08 1361
Java SE——12.异常（≠错误）《干货笔记》
javascript 性能优化实战：异步和延迟加载
小伙伴们全都Lucky！
12-11 576
本文探讨JavaScript性能优化中的异步加载与延迟加载技术。异步加载通过async/defer属性或动态创建script元素避免阻塞渲染；延迟加载则利用IntersectionObserver API按需加载非关键资源。二者结合可显著提升性能：异步加载核心脚本确保交互流畅，延迟加载减少初始请求量。实践表明，该方案能降低DOMContentLoaded时间30%以上，减少初始加载量90%，但需注意async脚本的执行顺序问题和延迟加载的回退处理。文中提供了完整的代码实现示例。
基于Java旅游信息推荐系统(源码+数据库+文档)
JIngJaneIL的博客
12-08 1155
本文介绍了基于SpringBoot+Vue的旅游信息推荐系统和学生成绩管理系统开发项目。系统采用前后端分离架构，后端使用SpringBoot框架简化企业级开发，前端采用Vue.js实现响应式界面，数据库选用MySQL。文章详细说明了系统设计原则、技术选型理由，并提供了代码示例和测试案例。项目包含完整功能演示视频，所有源码经过验证可正常运行。同时提供最新计算机毕业设计选题参考，文末附有源码获取方式。系统适用于大学生项目实战开发，具有模块化设计、安全性强等特点。
基于Java+SpringBoot+Vue的美甲店管理系统【附源码+文档+部署视频+讲解)
最新发布
小熊的博客
12-11 860
基于SpringBoot的美甲店管理系统开发案例，涵盖用户、美甲师和管理员三大角色功能模块，采用Vue+SpringBoot+MySQL技术栈实现。系统包含服务预约、订单管理、耗材采购等全流程数字化功能，采用MVC设计模式和B/S架构。包含用户、美甲师、管理员三类角色的功能模块，该系统聚焦美甲店的日常运营场景，通过用户端浏览服务与套餐、美甲师端处理预约与评价、管理员端统筹人员、业务与资源的模式，实现美甲店从服务展示、预约调度到耗材管理的全流程数字化，提升门店运营效率与服务体验。
内存屏障-给出一个乱序执行的实际例子
小狗爱吃黄桃罐头的博客
12-08 307
我们跑一个小小的demo看一看int X,Y;int r1,r2;X=1;r1 = Y;Y=1;r2 = X;;X=0;Y=0;detected++;return 0;
实现一个功能：springboot项目启动将controller地址拼接打印到txt文件
极客鼠之家
12-07 643
本文介绍了一种在SpringBoot项目启动时自动扫描Controller接口地址并写入TXT文件的方法。通过实现一个工具类ControllerUrlScanner，利用Spring上下文获取所有Controller Bean，反射解析@RequestMapping等注解路径，拼接类级和方法级路径，最终将完整接口地址按规范格式写入指定TXT文件。该方案支持自定义文件路径，可自动处理路径格式统一，并区分不同HTTP请求方法（GET/POST等）。适用于学生管理系统等需要快速获取API接口清单的场景，便于开发调
数据结构 —— 并查集
zz072320的博客
12-08 665
并查集是一种高效处理动态连通性问题的数据结构，主要用于元素分组和连通性判断。其核心操作包括查找(Find)元素所属集合的根节点，以及合并(Union)两个集合。通过路径压缩和加权标记优化，可显著提升性能。路径压缩使查找路径上的节点直接指向根节点，加权标记则在合并时保持树结构平衡。典型应用包括判断图的连通性和Kruskal最小生成树算法。并查集通过初始化(Init)、查找(Find)和合并(Join)三个基本操作，实现了高效的动态集合管理。
java面试:怎么保证消息队列当中的消息丢失、重复问题？
2301_80939853的博客
12-11 702
在面试的过程之中，假设你在简历当中填写了mq的相关技术，那面试官大概率会考察这方面的问题来看看你对mq相关知识的掌握程度，小编在这一块也被拷打过，今天就和大家一起来了解一下这方面的知识，希望大家都有所提升。
Spring Boot 项目集成模块- 2
qq_34823185的博客
12-07 1296
摘要 Spring Cloud LoadBalancer 提供了客户端负载均衡功能，支持轮询、随机等策略，与OpenFeign集成良好。整合步骤包括添加依赖、启用注解、配置策略，可通过RestTemplate或OpenFeign使用。相比Ribbon更轻量且支持响应式编程。 Spring Boot Cache 简化了缓存集成，支持Redis等多种实现。通过@EnableCaching启用，使用@Cacheable、@CachePut、@CacheEvict等注解管理缓存，可提升性能并降低数据库负载。配置简单
动态规划算法-子数组、子串系列（数组中连续的一段）：26.环绕字符串中唯一的子字符串
要努力去发光，而不是被照亮~
12-07 203
动态规划算法-子数组、子串系列（数组中连续的一段）：26.环绕字符串中唯一的子字符串解析
Java NIO技术深入解析与实战应用技巧
资源摘要信息:"JavaNIO浅析IO模型" Java NIO（New IO，Non-blocking IO）是Java提供的一种用于替代标准Java IO的新I/O API。从标题"JavaNIO浅析IO模型Java开发Java经验技巧共1"和描述"JavaNIO浅析IO模型Java开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值