nio介绍+原理+传统IO原理+与传统IO区别+案例

最新推荐文章于 2023-11-11 12:43:21 发布
最新推荐文章于 2023-11-11 12:43:21 发布
阅读量503 收藏 1
点赞数
分类专栏： nio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhou920786312/article/details/85222345
版权

nio介绍

  • 为所有的原始类型提供(Buffer)缓存支持。
  • 为字符集编码解码提供解决方案。
  • Channel ：一个新的原始I/O 抽象。
  • 支持锁和内存映射文件的文件访问接口。
  • 提供多路(non-bloking) 非阻塞式的高伸缩性网络I/O 。

nio原理

NIO技术省去了将操作系统的read buffer拷贝到程序的buffer, 以及从程序buffer拷贝到socket buffer的步骤

扩展

将 read buffer 拷贝到socket buffer的FileChannel.transferTo()方法就是这样的实现, 这个实现是依赖于操作系统底层的sendFile()实现的。

publicvoid transferTo(long position, long count, WritableByteChannel target)；

他的底层调用的是系统调用sendFile()方法；

sendfile(int out_fd, int in_fd, off_t *offset, size_t count)；

传统IO原理

 

  1. 先将文件内容从磁盘中拷贝到操作系统buffer
  2. 再从操作系统buffer拷贝到程序应用buffer
  3. 从程序buffer拷贝到socket buffer
  4. 从socket buffer拷贝到协议引擎.

传统的I/O程序读取文件内容, 并写入到另一个文件(或Socket), 会有较大的性能开销, 主要表现在一下两方面:

1. 上下文切换(context switch), 此处有4次用户态和内核态的切换

2. Buffer内存开销。一个是应用程序buffer, 另一个是系统读取buffer以及socket buffer

运行示意图如下

与传统IO区别

NIO技术省去了将操作系统的read buffer拷贝到程序的buffer, 以及从程序buffer拷贝到socket buffer的步骤

下图看不懂就跳过去（因为nio很复杂，不是下图可以完全解释的了的）

 

案例

客户端

package fei.com;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
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  ClientHandle implements Runnable {
    private String host;
    private int port;
    private Selector selector;
    private SocketChannel socketChannel;
    private volatile boolean stop;

    public ClientHandle(String host, int port) {
	this.host = host;
	this.port = port;
	try {
	    selector = Selector.open();
	    socketChannel = SocketChannel.open();
	    socketChannel.configureBlocking(false);
	} catch (IOException e) {
	    e.printStackTrace();
	    //异常停止
	    System.exit(1);
	}
    }
    /*
     * (non-Javadoc)
     *
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
	try {
	    doConnect();
	} catch (IOException e) {
	    e.printStackTrace();
	    System.exit(1);
	}
	while (!stop) {
	    try {
		selector.select(1000);
		Set<SelectionKey> selectedKeys = selector.selectedKeys();
		Iterator<SelectionKey> it = selectedKeys.iterator();
		SelectionKey key = null;
		while (it.hasNext()) {
		    key = it.next();
		    it.remove();
		    try {
			handleInput(key);
		    } catch (Exception e) {
			if (key != null) {
			    key.cancel();
			    if (key.channel() != null)
				key.channel().close();
			}
		    }
		}
	    } catch (Exception e) {
		e.printStackTrace();
		System.exit(1);
	    }
	}

	// 多路复用器关闭后，所有注册在上面的Channel和Pipe等资源都会被自动去注册并关闭，所以不需要重复释放资源
	if (selector != null)
	    try {
		selector.close();
	    } catch (IOException e) {
		e.printStackTrace();
	    }
    }

    
    private void doConnect() throws IOException {
	// 如果直接连接成功，则注册到多路复用器上，发送请求消息，读应答
	if (socketChannel.connect(new InetSocketAddress(host, port))) {
	    socketChannel.register(selector, SelectionKey.OP_READ);
	    doWrite(socketChannel);
	} else
	    socketChannel.register(selector, SelectionKey.OP_CONNECT);
    }

    private void doWrite(SocketChannel sc) throws IOException {
	byte[] req = "你好服务器,我是客户端，你收到我的消息没?".getBytes();
	ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);
	writeBuffer.put(req);
	writeBuffer.flip();
	sc.write(writeBuffer);
	if (!writeBuffer.hasRemaining())
	    System.out.println("客户端发生消息完毕。");
    }
    
    
    private void handleInput(SelectionKey key) throws IOException {

	if (key.isValid()) {
	    // 判断是否连接成功
	    SocketChannel sc = (SocketChannel) key.channel();
	    if (key.isConnectable()) {
		if (sc.finishConnect()) {
		    sc.register(selector, SelectionKey.OP_READ);
		    doWrite(sc);
		} else
		    System.exit(1);// 连接失败，进程退出
	    }
	    if (key.isReadable()) {
		ByteBuffer readBuffer = ByteBuffer.allocate(1024);
		int readBytes = sc.read(readBuffer);
		if (readBytes > 0) {
		    readBuffer.flip();
		    byte[] bytes = new byte[readBuffer.remaining()];
		    readBuffer.get(bytes);
		    String body = new String(bytes, "UTF-8");
		    System.out.println("客户端收到的消息: " + body);
		    this.stop = true;
		} else if (readBytes < 0) {
		    // 对端链路关闭
		    key.cancel();
		    sc.close();
		} else; // 读到0字节，忽略
		   
	    }
	}

    }
    public static void main(String[] args) {

	int port = 8080;
	 
	new Thread(new ClientHandle("127.0.0.1", port), "客户端01").start();
		
   }

}

服务端

package fei.com;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class  ServerHandle implements Runnable {

    private Selector selector;

    private ServerSocketChannel servChannel;

    private volatile boolean stop;

    /**
     * 初始化多路复用器、绑定监听端口
     * 
     * @param port
     */
    public ServerHandle(int port) {
	try {
	    selector = Selector.open();
	    servChannel = ServerSocketChannel.open();
	    servChannel.configureBlocking(false);
	    servChannel.socket().bind(new InetSocketAddress(port), 1024);
	    servChannel.register(selector, SelectionKey.OP_ACCEPT);
	    System.out.println("服务器启动,端口是 : " + port);
	} catch (IOException e) {
	    e.printStackTrace();
	    System.exit(1);
	}
    }

    public void stop() {
	this.stop = true;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
	while (!stop) {
	    try {
		selector.select(1000);
		Set<SelectionKey> selectedKeys = selector.selectedKeys();
		Iterator<SelectionKey> it = selectedKeys.iterator();
		SelectionKey key = null;
		while (it.hasNext()) {
		    key = it.next();
		    it.remove();
		    try {
			handleInput(key);
		    } catch (Exception e) {
			if (key != null) {
			    key.cancel();
			    if (key.channel() != null)
				key.channel().close();
			}
		    }
		}
	    } catch (Throwable t) {
		t.printStackTrace();
	    }
	}

	// 多路复用器关闭后，所有注册在上面的Channel和Pipe等资源都会被自动去注册并关闭，所以不需要重复释放资源
	if (selector != null)
	    try {
		selector.close();
	    } catch (IOException e) {
		e.printStackTrace();
	    }
    }

    private void handleInput(SelectionKey key) throws IOException {

	if (key.isValid()) {
	    // 处理新接入的请求消息
	    if (key.isAcceptable()) {
		// Accept the new connection
		ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
		SocketChannel sc = ssc.accept();
		sc.configureBlocking(false);
		// Add the new connection to the selector
		sc.register(selector, SelectionKey.OP_READ);
	    }
	    if (key.isReadable()) {
		// Read the data
		SocketChannel sc = (SocketChannel) key.channel();
		ByteBuffer readBuffer = ByteBuffer.allocate(1024);
		int readBytes = sc.read(readBuffer);
		if (readBytes > 0) {
		    readBuffer.flip();
		    byte[] bytes = new byte[readBuffer.remaining()];
		    readBuffer.get(bytes);
		    String body = new String(bytes, "UTF-8");
		    System.out.println("服务器收到消息为 : " + body);
		    doWrite(sc, "我是服务器，我已经收到你消息了");
		} else if (readBytes < 0) {
		    // 对端链路关闭
		    key.cancel();
		    sc.close();
		} else ; // 读到0字节，忽略
	    }
	}
    }

    private void doWrite(SocketChannel channel, String response)
	    throws IOException {
	if (response != null && response.trim().length() > 0) {
	    byte[] bytes = response.getBytes();
	    ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
	    writeBuffer.put(bytes);
	    writeBuffer.flip();
	    channel.write(writeBuffer);
	}
    }
    
    
    public static void main(String[] args) throws IOException {
    	int port = 8080;
    	 
    	ServerHandle timeServer = new ServerHandle(port);
    	new Thread(timeServer, "服务器").start();
    }
}

结果：

客户端

服务端

 

勤径苦舟
关注
专栏目录
Java IO流：NIO 介绍及使用
栗筝i的博客
08-16 215
NIO 也叫 Non-Blocking IO 是同步非阻塞的 IO 模型。线程发起 IO 请求后，立即返回。同步指的是必须等待 IO 缓冲区内的数据就绪，而非阻塞指的是，用户线程不原地等待 IO 缓冲区，可以先做一些其他操作，但是要定时轮询检查 IO 缓冲区数据是否就绪。Java 中的 NIO 是 new IO的意思。其实是 NIO 加上 IO 多路复用技术。
Java NIO：IO与NIO的区别
yangrendong的专栏
05-24 280
一、概念 NIO即New IO，这个库是在JDK1.4中才引入的。NIO和IO有相同的作用和目的，但实现方式不同，NIO主要用到的是块，所以NIO的效率要比IO高很多。在Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。 二、NIO和IO的主要区别 下表总结了Java IO和NIO之间的主要区别： IO NIO 面向流 ...
IO原理
qq_28854219的博客
07-10 1843
目录IO设备分类IO设备组成设备控制器直接存储器存储（DMA）中断 IO设备分类 I/O设备一般分为两种： 块设备：每个块都有自己的地址，传输依次是以块为单位进行的通常在512-32768之间，典型的就是磁盘 字符设备：没有固定的地址，每次以字符为单位接收或发送一个字符流。如键盘，鼠标 IO设备组成 I/O设备一般由机械部分和电子部分组成，电子部分就称为设备控制器或者适配器 设备控制器 设备控制器...
NIO与传统IO的区别
热门推荐
周宏亮G的日志
06-26 5万+
 传统的socket IO中，需要为每个连接创建一个线程，当并发的连接数量非常巨大时，线程所占用的栈内存和CPU线程切换的开销将非常巨大。使用NIO，不再需要为每个线程创建单独的线程，可以用一个含有限数量线程的线程池，甚至一个线程来为任意数量的连接服务。由于线程数量小于连接数量，所以每个线程进行IO操作时就不能阻塞，如果阻塞的话，有些连接就得不到处理，NIO提供了这种非阻塞的能力。 小
【转载】对比Java.nio 和 Java.io
decision06的专栏
12-11 310
原作者：Davide Pisano，编译：ImportNew - 储晓颖 转载：http://www.importnew.com/1178.html 本文并非Java.io或Java.nio的使用手册，也不是如何使用Java.io与Java.nio的技术文档。这里只是尝试比较这两个包，用最简单的方式突出它们的区别和各自的特性。Java.nio提出了新的流(stream)通讯概念并且加入了新...
java中的IO和NIO的区别原理
jubaoquan的博客
01-16 1821
Java NIO和IO的主要区别 IO NIO 面向Stream 面向Buffer 阻塞IO 非阻塞IO   Selectors 面向Stream和面向Buffer Java NIO和IO之间最大的区别是IO是面向流（Stream）的，NIO是面向块（buffer）的，所以，这意味着什么？ 面向流
NIO与传统IO区别
gltncx11的博客
03-16 2472
NIO结构 　　Channel：通道，连接客户端和服务端的一个管道，管道内可以双向传输数据。 　　Selector：选择器，可以想象成一个环状传送带，上面可以介入很多管道，selector还可以对每个管道设置感兴趣的颜色 （连接（红色），读（黄色），写（蓝色），接收数据）。当selector开始轮询的时候selector这个传送带就一直转动，当某个管道被传送到感兴趣事件检查点的时候，selecto...
Java NIO与传统IO：文件性能测试对比与内存映射优化
本篇文章主要探讨了Java中文件性能测试的不同方法，包括传统的IO操作和Java NIO（New Input/Output）的优化。首先，我们回顾了传统IO读取机制，如`FileInputStream`中的`read()`方法，该方法通过系统调用内核的底层...
Java NIO与传统IO深度比较：揭秘性能提升的关键优势
在开始探索Java NIO（New IO）与传统IO的奥妙之前，让我们首先从它们的基本概念谈起。传统IO，也被称作阻塞IO（Blocking IO），它在JDK 1.4之前的Java版本中被广泛使用。这一模型简单直观，但随着网络和存储技术的...
传统IO与NIO
lishuwen7986的博客
10-21 133
一、传统IO编程 1. 阻塞式I/O的通信模型示意图 每个客户端连接过来后，服务端都会启动一个线程去处理该客户端的请求 2. 业务场景 客户端每隔两秒发送字符串给服务端，服务端收到之后打印到控制台 3. 代码实现 服务端实现 ： public class IOServer { public static void main(String[] args) throws Exception { //创建服务端socket对象 ServerSocket server
深入理解IO和NIO的原理和区别
最新发布
weixin_62079735的博客
11-11 321
在计算机编程领域，IO（Input/Output）和NIO（Non-blocking Input/Output）代表了两种截然不同的输入输出模型，它们在数据输入和输出方面采用不同的理念和机制。本文将深入剖析IO和NIO的原理，以及它们之间的主要区别。
IO/NIO 例子
王帆的专栏
08-07 1115
题目：      passport日志由以下三个字段组成，用户名、访问时间、访问者的IP地址。 要求在passport日志中进行以下操作：     1、找到访问次数最多的用户名，并求出访问次数     2、找到指定用户的访问记录    要求用IO/NIO实现 思路如下：   (1)首先将文件读进来，一行一行的处理   (2)对每一行，将姓名作为key,访问的记录对象作为val
java的io和nio例子
weixin_45771158的博客
07-10 288
java的io以及nio例子
IO 原理
这个人很懒什么都没有~
10-22 837
NIO的每个发起read请求的线程自己去进行数据是否就绪的轮询，而IO多路复用是专门找了一个线程去帮其他所有的read请求轮询数据是否就绪。下，异步IO模型在2.6版本才引入，目前并不完善，其底层实现仍使用epoll，与IO多。在IO多路复用模型中通过select/epoll系统调用，单个应用程序的线程，可以不。而write系统调用，是。发，它们的输入(Input）和输出（Output）的处理，在编程的流程上，都是一致。4.在用户程序中，无论是Socket的IO、还是文件IO操作，都属于上层应用的开。
为什么我觉得 Java 的 IO 很复杂？
jinshitou2012的专栏
02-20 181
最近又把流的概念，原理复习了一下，发现一片文章写得很好，转载记录一下。侵删。 作者：安馁碗 链接：https://www.zhihu.com/question/67535292/answer/1248887503 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 初学者觉得复杂是很正常的，归根结底是因为没有理解JavaIO框架的设计思想： 可以沿着这条路想一想： 1，学IO流之前，我们写的程序，都是在内存里自己跟自己玩。比如，你声明个变量，创建个数组，创建个..
java中io以及nio的基本案例
有梦想的咸鱼的博客
03-23 737
1、java中io和nio的区别个人理解，主要在于io是面向流，而nio是面向缓冲区的，io（bio）同步阻塞式的输入输出，而nio是同步非阻塞式的输出输出。2、io复制文件代码import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.Inp...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值