NIO通信学习

最新推荐文章于 2024-05-22 12:03:15 发布
最新推荐文章于 2024-05-22 12:03:15 发布
阅读量825 收藏
点赞数
分类专栏： java IO通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JY_He/article/details/52164027
版权
今天在学jetty时,发现jetty是采用非阻塞I/O进行通信的,之前对NIO是一头雾水,很不理解,今天再次学习NIO通信,这部分也算Java中的重点难点部分,不能一下子全掌握,就今天学习内容进行各总结:


java Nio 通信与Bio通信主要不同点:
1.Nio中的单个channel即可支持读操作也可以支持写操作,而bio中读操作要用inputstream,写操作要outputstream.
2.nio 采用byteBuffer 作为内存缓存区,向channel里写或者度操作,bio基本是用byte[]
3.nio采用 selector组件轮询读取就绪channel


Selector（选择器）是Java NIO中能够检测一到多个NIO通道，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接。


为什么使用Selector?
 
仅用单个线程来处理多个Channels的好处是，只需要更少的线程来处理通道。事实上，可以只用一个线程处理所有的通道。对于操作系统来说，线程之间上下文切换的开销很大，而且每个线程都要占用系统的一些资源（如内存）。因此，使用的线程越少越好。
 
但是，需要记住，现代的操作系统和CPU在多任务方面表现的越来越好，所以多线程的开销随着时间的推移，变得越来越小了。实际上，如果一个CPU有多个内核，不使用多任务可能是在浪费CPU能力。不管怎么说，关于那种设计的讨论应该放在另一篇不同的文章中。在这里，只要知道使用Selector能够处理多个通道就足够了。


Selector的创建

通过调用Selector.open()方法创建一个Selector，如下：

Selector selector = Selector.open();
向Selector注册通道
为了将Channel和Selector配合使用，必须将channel注册到selector上。通过SelectableChannel.register()方法来实现，如下： 

channel.configureBlocking(false);  
SelectionKey key = channel.register(selector, Selectionkey.OP_READ);
与Selector一起使用时，Channel必须处于非阻塞模式下。这意味着不能将FileChannel与Selector一起使用，因为FileChannel不能切换到非阻塞模式。而套接字通道都可以。
 
注意: register()方法的第二个参数。这是一个“interest集合”，意思是在通过Selector监听Channel时对什么事件感兴趣。可以监听四种不同类型的事件： 

Connect
Accept
Read
Write
通道触发了一个事件意思是该事件已经就绪。所以，某个channel成功连接到另一个服务器称为“连接就绪”。一个server socket channel准备好接收新进入的连接称为“接收就绪”。一个有数据可读的通道可以说是“读就绪”。等待写数据的通道可以说是“写就绪”。
这四种事件用SelectionKey的四个常量来表示： 
SelectionKey.OP_CONNECT  
SelectionKey.OP_ACCEPT  
SelectionKey.OP_READ  
SelectionKey.OP_WRITE

如果你对不止一种事件感兴趣，那么可以用“位或”操作符将常量连接起来，如下：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
当向Selector注册Channel时，register()方法会返回一个SelectionKey对象,通过Selector选择通道
 
一旦向Selector注册了一或多个通道，就可以调用几个重载的select()方法。这些方法返回你所感兴趣的事件（如连接、接受、读或写）已经准备就绪的那些通道。换句话说，如果你对“读就绪”的通道感兴趣，select()方法会返回读事件已经就绪的那些通道。
 
下面是select()方法：（该方法是阻塞方法） 

int select()
int select(long timeout)
int selectNow()
elect()阻塞到至少有一个通道在你注册的事件上就绪了。
 
select(long timeout)和select()一样，除了最长会阻塞timeout毫秒(参数)。
 
selectNow()不会阻塞，不管什么通道就绪都立刻返回（译者注：此方法执行非阻塞的选择操作。如果自从前一次选择操作后，没有通道变成可选择的，则此方法直接返回零。
 
select()方法返回的int值表示有多少通道已经就绪。亦即，自上次调用select()方法后有多少通道变成就绪状态。如果调用select()方法，因为有一个通道变成就绪状态，返回了1，若再次调用select()方法，如果另一个通道就绪了，它会再次返回1。如果对第一个就绪的channel没有做任何操作，现在就有两个就绪的通道，但在每次select()方法调用之间，只有一个通道就绪了。
附加的对象
 
可以将一个对象或者更多信息附着到SelectionKey上，这样就能方便的识别某个给定的通道。例如，可以附加与通道一起使用的Buffer，或是包含聚集数据的某个对象。使用方法如下：

附加的对象
 
可以将一个对象或者更多信息附着到SelectionKey上，这样就能方便的识别某个给定的通道。例如，可以附加与通道一起使用的Buffer，或是包含聚集数据的某个对象。使用方法如下： 
electionKey.attach(theObject);  
Object attachedObj = selectionKey.attachment();
还可以在用register()方法向Selector注册Channel的时候附加对象，如： 
SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);
下面是服务端以及客户端的NIO通信的实现代码，其中注释不保证全部安全，若有出错，欢迎指出：

服务端:

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.nio.ByteBuffer;
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.util.Iterator;
import java.util.Set;

public class ServerTest {

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

	private static void server() {
		//ServerSocketChannel通道引用
		ServerSocketChannel channel=null;
		
		try {
			//创建selector
			Selector selector=Selector.open();
			//open方法来打开一个未绑定的ServerSocketChannel实例
			channel=ServerSocketChannel.open();
			//把channel设置成非阻塞
			channel.configureBlocking(false);
			//timewait状态时，就可复用其端口,对于大量连接且经常有timewait时适用
			channel.socket().setReuseAddress(true);
			//与端口绑定
			channel.bind(new InetSocketAddress(8082));
			
			//在SelectionKey对象的有效期间，Selector会一直监控与SelectionKey对象相关的事件，如果事件发生，就会把SelectionKey对象加入到selected-keys集合中
			//将selector对象绑定到监听信道上,并在注册过程中指出该信道进行OP_ACCEPT操作 
			channel.register(selector, SelectionKey.OP_ACCEPT,new Integer(1));
			/*SelectionKey.OP_ACCEPT —— 接收连接继续事件，表示服务器监听到了客户连接，服务器可以接收这个连接了
			SelectionKey.OP_CONNECT —— 连接就绪事件，表示客户与服务器的连接已经建立成功
			SelectionKey.OP_READ —— 读就绪事件，表示通道中已经有了可读的数据，可以执行读操作了（通道目前有数据，可以进行读操作了）
			SelectionKey.OP_WRITE —— 写就绪事件，表示已经可以向通道写数据了（通道目前可以用于写操作）*/
			
			//反复循环,等待IO
			while(true){
				//select方法会阻塞等待，直到至少有一个注册信道中有感兴趣的操作准备就绪,返回值大于0,表明有一个或更多个通道就绪了
				if(selector.select()>0){
					//将就绪的对象放到set集合中
					Set<SelectionKey> sets=selector.selectedKeys();
					//通过迭代器遍历,依次处理selector上的每个已选择的SelectionKey
					Iterator<SelectionKey> keys=sets.iterator();
					while(keys.hasNext()){
						//获取具体的selectionkey
						SelectionKey key=keys.next();
						//Selector不会自己从已选择键集中移除SelectionKey实例,必须在处理完通道时自己移除。
						//下次该通道变成就绪时，Selector会再次将其放入已选择键集中。
						keys.remove();
						
						//selectionKey对应的通道是包含客户端的连接请求  
						if(key.isAcceptable()){
							key.attach(new Integer(1));
							//调用accept方法接受连接，产生服务器端对应的SocketChannel
							SocketChannel socketChannel=((ServerSocketChannel) key.channel()).accept();
							//同样设置为非阻塞
							socketChannel.configureBlocking(false);
							//同样将socketChannel注册到selector上,socketChannel设置成准备接受其他请求
							socketChannel.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE);
						}
						//selectionKey对应的通道有数据需要读取
						if(key.isReadable()){
							//获取该SelectionKey对应的Channel，该Channel中有可读的数据
							SocketChannel socketChannel=(SocketChannel) key.channel();
							//定义准备执行读取数据的ByteBuffer,NIO通信是基于Buffer块的 
							ByteBuffer buf=ByteBuffer.allocate(1024);
							ByteArrayOutputStream output=new ByteArrayOutputStream();
							int len=0;
							while((len=socketChannel.read(buf))!=0){
								buf.flip();
								//remaining()返回剩余的可用长度，此长度为实际读取的数据长度
								byte[] b=new byte[buf.remaining()];
								buf.get(b);
								output.write(b);
								buf.clear();
							}
							String str=new String(output.toByteArray());
							key.attach(str);
							
						}
						//selectionKey对应的通道是否可以写入数据
						if(key.isWritable()){
							Object object=key.attachment();
							String attach=object!=null?"server replay: "+object.toString():"server replay: ";
							//获取该SelectionKey对应的Channel，在该Channel中写入数据
							SocketChannel socketChannel=(SocketChannel) key.channel();
							socketChannel.write(ByteBuffer.wrap(attach.getBytes()));
						}
					}
				}	
			}
		} catch (SocketException e) {
			e.printStackTrace();
		} catch (ClosedChannelException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(channel!=null){
				try {
					//关闭通道
					channel.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

}


客户端: 

import java.io.ByteArrayOutputStream;  
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;  
  
public class ClientTest {  
  
    public static void main(String[] args) throws Exception {  
                client();  
    }  
      
    public static void client() { 
    	//socket这里创建的是SocketChannel
        SocketChannel channel=null;  
        try {  
            //打开selector
            Selector selector=Selector.open();
            //打开SocketChannel通道
            channel = SocketChannel.open();  
            //非阻塞
            channel.configureBlocking(false);
            //连接相应的端口号
            channel.connect(new InetSocketAddress(8020)); 
            //channel注册到selector上,设置成接受请求
            channel.register(selector, SelectionKey.OP_CONNECT);  
              
            while(true){  
                if(selector.select()>0){  
                      
                    Iterator<SelectionKey> set=selector.selectedKeys().iterator();  
                    while(set.hasNext()){  
                        SelectionKey key=set.next();  
                        set.remove();  
                          
                        SocketChannel ch=(SocketChannel) key.channel();  
                        if(key.isConnectable()){  
                            ch.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE,new Integer(1));  
                            ch.finishConnect();  
                        }  
                          
                        if(key.isReadable()){  
                            key.attach(new Integer(1));  
                            ByteArrayOutputStream output=new ByteArrayOutputStream();  
                            ByteBuffer buffer=ByteBuffer.allocate(1024);  
                            int len=0;  
                            while((len=ch.read(buffer))!=0){  
                                buffer.flip();  
                                byte by[]=new byte[buffer.remaining()];  
                                buffer.get(by);  
                                output.write(by);  
                                buffer.clear();  
                            }  
                            System.out.println(new String(output.toByteArray()));  
                            output.close();  
                        }  
                          
                        if(key.isWritable()){  
                            key.attach(new Integer(1));  
                            ch.write(ByteBuffer.wrap((("client say: hi")).getBytes()));  
                        }  
                    }  
                }  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        }finally{  
            try {  
                channel.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
      
    static class ClientRunnable implements Runnable{  
  
        private SocketChannel ch;  
          
        private ClientRunnable(SocketChannel ch){  
            this.ch=ch;  
        }  
          
        @Override  
        public void run() {  
            try {  
                while(true){  
                    ch.write(ByteBuffer.wrap((("client say:hi")).getBytes()));  
                    Thread.sleep(5000);  
                }  
            } catch (Exception e) {  
                e.printStackTrace();  
                try {  
                    ch.close();  
                } catch (IOException e1) {  
                    e1.printStackTrace();  
                }  
            }  
        }  
    }   
}

上述学习内容参考了这篇博文: http://hbiao68.iteye.com/blog/1930884



JY_He
关注
专栏目录
NIO入门学习源码
07-03
3. **网络编程**：NIO在TCP和UDP通信中的应用，例如聊天服务器、游戏服务器等。 **NIO的优点：** 1. **非阻塞I/O**：线程不会因为等待数据而被阻塞，提高了系统的并发性和响应速度。 2. **内存直接映射**：通过...
NIO通信 代码流程
weixin_48293310的博客
03-09 366
NIO和BIO BIO是阻塞IO，当进行连接时，每次消耗一个线程，并且如果没有数据读取，则会一直占用该线程，直到关闭连接，十分消耗资源； NIO是非阻塞IO，可以一个线程创建多个连接，相比于阻塞IO，能极大的减少资源的占用，而且不是阻塞的，当连接的对象有读写操作时，才会进行处理，期间没有操作时，可以处理其他任务； NIO的三个核心：buffer，channel，selector buffer是缓冲区，所有的数据的读取和写入都必须经过缓冲区，然后通过channel写入到server或者从server读取数据，
NIO异步通讯原理
wangqsse的博客
09-06 2095
1、相关概念 （1）阻塞(Block)和非阻塞(Non-Block): 关注的是线程或者进程在运行过程中是否等待调用结果的状态，多用于server端数据处理方式。 阻塞：程序运行过程中，当前线程或者进程在数据返回前会被操作系统挂起，只有等到返回数据后才继续执行（BIO模型） 非阻塞：当前线程或者进程运行过程中，不管数据有没有准备好都不会被操作系统挂起而是直接继续执行其他工作。 （2）同步(Synchronization)和异步(Asynchronous)的方式:...
Java NIO通信基础详解
xintingandzhouyang的专栏
03-06 506
高性能的Java通信，绝对离不开Java NIO技术，现在主流的技术框架或中间件服务器，都使用了Java NIO技术，譬如Tomcat、Jetty、Netty。学习和掌握NIO技术，已经不是一项加分技能，而是一项必备技能。不管是面试，还是实际开发，作为Java的“攻城狮”，都必须掌握NIO的原理和开发实践技能。 3.1　Java NIO简介 在1.4版本之前，Java IO类库是阻塞IO；从1.4版本开始，引进了新的异步IO库，被称为Java New IO类库，简称为JAVA NIO。New IO类库的
NIO通信实现
zhangm2020的博客
08-18 691
目录 基于channel通道实现通信 服务端代码 客户端代码 通信结果 Channel通道与流的区别 基于Selector选择器服务端实现通信 服务端代码 通信结果
Java Socket实现NIO通信
在路上
12-24 2443
手写NIO通信,其实并不复杂
javaNIO学习笔记
08-22
### Java NIO 学习笔记 #### 一、概述 Java NIO (Non-Blocking IO，也称为 Java New IO)，是 Java 对传统 IO 模型的一次重大改进，旨在提高程序处理大量并发连接的能力。NIO 的核心组件包括 Channels、Buffers 和 ...
NIO和Netty框架的学习
11-27
通过深入学习NIO和Netty，你将能够构建出高效、稳定的网络应用，无论是开发WebSocket服务、TCP服务器还是其他协议的网络应用，Netty都能为你提供强大的支持。不断实践和探索，你将在网络编程的道路上越来越熟练。
NIO实现客户端之间通信
11-09
NIO实现客户端与客户端之间的通信，通过中心服务进行消息转发。
BIO NIO
bintoYu的博客
05-23 231
NIO和BIO IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO BIO和NIO的区别： 面向流与面向缓冲 IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节。而NIO则可以将数据先放入缓存区，稍后再读取想要的部分。（但其缺陷在于Thread需要反复检查buffer中是否包含所有想要处理的数据） 阻塞与非...
快速入门Java NIO（Not I/O）的网络通信框架--Netty
qq_55272229的博客
01-14 1337
Netty 是一个异步(基于多线程)的、基于事件驱动(多路复用的那写事件驱动)的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端末尾练习 简记 c/s各组件结构/*** 可以简单记忆是这是一个二级的关系* 通道是双向连接通道,客户端和服务器端都可以进行处理* 服务器端使用的是ServerSocketChannel 而客户端是SocketChannel* eventloopgroup 是相当于封装了nio中的各个触发事件。
NIO网络通信
zhaojianyin
05-28 539
NIO非阻塞式网络通信1.简单介绍阻塞式：客户端发送请求给服务端，服务端不能确定客户端发过来的数据真实有效时，这个线程会阻塞，此时服务端的线程等待。当客户端发送大量数据时，服务端使用多个线程进行数据传输。（使用多线程解决IO阻塞问题）即使是使用多线程，那么一个服务器的线程数量还是有效的，一旦有阻塞就无法做其他事情。这就是传统IO的阻塞问题。 非阻塞式： 添加了选择器，将每个通道注册到该选择器上，（
通信架构，你懂吗？
qq_45838796的博客
02-28 1078
与NIO不同，当进行读写操作时，只须直接调用API的read或write方法即可, 这两种方法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区,对于写操作而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通知应用程序。Channel 表示 IO 源与目标打开的连接。（ii）BIO 中的 stream 是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道(Channel)是双向的，可以读操作，也可以写操作。
java.nio.channels.ClosedChannelException错误的解决方案
最新发布
2301_79779756的博客
05-22 991
java.nio.channels.ClosedChannelException 是 Java NIO（非阻塞 I/O）中的一个异常，表示某个通道（如文件通道、套接字通道等）已经被关闭，但代码尝试在该通道上执行 I/O 操作。在 Java NIO 中，通道（Channel）是数据传输的主要通道，它提供了将数据从源传输到目标或从目标传输到源的能力。
JAVA系列 —— 阻塞非阻塞 同步异步 IO模型及其应用 NIO实现原理
JasonChen3318的博客
09-02 1368
一、NIO的与IO的区别： 1、IO是面向流的，NIO是面向缓冲的； 2、IO是阻塞的，NIO是非阻塞的； 3、IO是单线程的，NIO 是通过选择器来模拟多线程的； 1. 通道 通道 Channel 是对原 I/O 包中的流的模拟，可以通过它读取和写入数据。 通道与流的不同之处在于，流只能在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类)，而...
NIO之完成网络通信
2301_76238237的博客
05-02 962
蚂蚁面试比较重视基础，所以Java那些基本功一定要扎实。蚂蚁的工作环境还是挺赞的，因为我面的是稳定性保障部门，还有许多单独的小组，什么三年1班，很有青春的感觉。面试官基本水平都比较高，基本都P7以上，除了基础还问了不少架构设计方面的问题，收获还是挺大的。经历这次面试我还通过一些渠道发现了需要大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。
打牢Netty基础，一文带你彻底搞懂Java的Nio多路复用！
greatming666的博客
03-01 2543
Java的NIO多路复用是一个重要的概念也是学习Netty的基础。NIO多路复用允许单个线程管理多个连接（Socket通道），通过选择器（Selector）同时监控多个通道的状态，从而实现高效的网络通信。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值