Java NIO 浅析

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量114 收藏
点赞数
分类专栏： Java笔记 文章标签： java 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_6605/article/details/82474290
版权

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();
				}
			}
		}
	}
}

 

 

       

 

 

      

 

 

 

iteye_6605
关注
专栏目录
JAVA NIO浅析
u012133048的博客
09-21 211
JAVA NIO 本文算是把一些讲的比较清晰的帖子，拼凑了一番，修改了部分描述不准确的，以及个人觉得比较混淆的表达方式。补充了一些容易忽略的注意点，以及理解上的小心得。站在各位前辈的肩膀上，总是能走不少弯路。 主要参考的博客是：https://blog.csdn.net/hlx20080808/article/details/78053556 ...
Java NIO浅析
wudiazu的博客
03-15 689
NIO（Non-blocking I/O，在Java领域，也称为New I/O），是一种同步非阻塞的I/O模型，也是I/O多路复用的基础，已经被越来越多地应用到大型应用服务器，成为解决高并发与大量连接、I/O处理问题的有效方式。那么NIO的本质是什么样的呢？它是怎样与事件模型结合来解放线程、提高系统吞吐的呢？本文会从传统的阻塞I/O和线程池模型面临的问题讲起，然后对比几种常见I/O模型，一步步分析...
java NIO浅析
taotao12312的博客
12-18 198
NIO与IO的主要区别是：1、IO多路复用 2、IO流与NIO缓冲区 阻塞与非阻塞（IO多路复用） 传统IO是阻塞的，当用户线程发出IO请求之后，内核会去查看数据是否就绪，如果没有就绪就会等待数据就绪，而用户线程就会处于阻塞状态，用户线程交出CPU。当数据就绪之后，内核会将数据拷贝到用户线程，并返回结果给用户线程，用户线程才解除block状态。此外由于每个连接都需要创建一个线程，...
java nio 最大连接数_Java NIO浅析
weixin_35103924的博客
02-16 573
准备知识同步、异步、阻塞、非阻塞同步和异步说的是服务端消息的通知机制，阻塞和非阻塞说的是客户端线程的状态。已客户端一次网络请求为例做简单说明：同步同步是指一次请求没有得到结果之前就不返回。异步请求不会立刻得到最终结果，服务器处理完成再异步通知客户端。阻塞请求结果返回之前，当前线程被挂起。在此期间不能做任何其他的事情。非阻塞请求立即返回，后续由客户端时不时的询问服务器结果或者服务器异步回调。同步IO...
JavaNIO浅析IO模型Java开发Java经验技巧共1
11-22
Java NIO，全称为New Input/Output，是Java在1.4版本引入的一个新特性，为Java程序员提供了更高效的数据传输方式。与传统的IO模型相比，NIO具有非阻塞、多路复用等优点，尤其适用于高并发、低延迟的网络应用。本文将...
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的一个高性能、异步事件...
java7源码-java-nio-master:Java
06-04
java-nio-master java Nio 主要内容： （1） 按操作方式分类结构图： （2）按操作对象分类结构图 IO流的分类： 按照流的流向分，可以分为输入流和输出流； 按照操作单元划分，可以划分为字节流和字符流； 按照流的...
Java企业面试题3
最新发布
m0_74972727的博客
09-15 301
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 566
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1088
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 111
");
Spring AMQP给消息添加头信息
yong472727322的博客
09-10 304
【代码】Spring AMQP给消息添加头信息。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 883
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 321
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1139
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1042
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
探索Java分布式服务远程调用技术详解
本文探讨了多种远程通讯技术，如RMI（Remote Method Invocation）、MINA（Java NIO多线程网络应用程序框架）、ESB（Enterprise Service Bus）、Burlap、Hessian、SOAP（Simple Object Access Protocol）、EJB...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值