NIO基础详解

最新推荐文章于 2024-09-28 11:40:23 发布
最新推荐文章于 2024-09-28 11:40:23 发布
阅读量294 收藏 1
点赞数
分类专栏： NIO

Netty 是基于Java NIO 封装的网络通讯框架，只有充分理解了 Java NIO 才能理解好Netty的底层设计。Java NIO 由三个核心组件组件：

  • Buffer

  • Channel

  • Selector

缓冲区 Buffer

Buffer 是一个数据对象，我们可以把它理解为固定数量的数据的容器，它包含一些要写入或者读出的数据。

在 Java NIO 中，任何时候访问 NIO 中的数据，都需要通过缓冲区（Buffer）进行操作。读取数据时，直接从缓冲区中读取，写入数据时，写入至缓冲区。NIO 最常用的缓冲区则是 ByteBuffer。下图是 Buffer 继承关系图：

每一个 Java 基本类型都对应着一种 Buffer，他们都包含这相同的操作，只不过是所处理的数据类型不同而已。

通道 Channel

Channel 是一个通道，它就像自来水管一样，网络数据通过 Channel 这根水管读取和写入。传统的 IO 是基于流进行操作的，Channle 和类似，但又有些不同：

区别流通过Channel
支持异步不支持支持
是否可双向传输数据不能，只能单向可以，既可以从通道读取数据，也可以向通道写入数据
是否结合 Buffer 使用不必须结合 Buffer 使用
性能较低较高

正如上面说到的，Channel 必须要配合 Buffer 一起使用，我们永远不可能将数据直接写入到 Channel 中，同样也不可能直接从 Channel 中读取数据。都是通过从 Channel 读取数据到 Buffer 中或者从 Buffer 写入数据到 Channel 中，如下：

简单点说，Channel 是数据的源头或者数据的目的地，用于向 buffer 提供数据或者读取 buffer 数据，并且对 I/O 提供异步支持。

下图是 Channel 的类图（http://blog.csdn.net/tsyj810883979/article/details/6876594）

Channel 为最顶层接口，所有子 Channel 都实现了该接口，它主要用于 I/O 操作的连接。定义如下：

 

  1. public interface Channel extends Closeable {

  3.     /**
  4.      * 判断此通道是否处于打开状态。 
  5.      */
  6.     public boolean isOpen();

  8.     /**
  9.      *关闭此通道。
  10.      */
  11.     public void close() throws IOException;

  13. }
 

最为重要的Channel实现类为：
 

  • FileChannel：一个用来写、读、映射和操作文件的通道
  • DatagramChannel：能通过 UDP 读写网络中的数据
  • SocketChannel: 能通过 TCP 读写网络中的数据
  • ServerSocketChannel：可以监听新进来的 TCP 连接，像 Web 服务器那样。对每一个新进来的连接都会创建一个 SocketChannel
 

多路复用器 Selector
 

多路复用器 Selector，它是 Java NIO 编程的基础，它提供了选择已经就绪的任务的能力。从底层来看，Selector 提供了询问通道是否已经准备好执行每个 I/O 操作的能力。简单来讲，Selector 会不断地轮询注册在其上的 Channel，如果某个 Channel 上面发生了读或者写事件，这个 Channel 就处于就绪状态，会被 Selector 轮询出来，然后通过 SelectionKey 可以获取就绪 Channel 的集合，进行后续的 I/O 操作。
 

Selector 允许一个线程处理多个 Channel ，也就是说只要一个线程复杂 Selector 的轮询，就可以处理成千上万个 Channel ，相比于多线程来处理势必会减少线程的上下文切换问题。下图是一个 Selector 连接三个 Channel ：
 

 

实例
 

服务端
 

 

  1. public class NIOServer {

  3.     /*接受数据缓冲区*/
  4.     private ByteBuffer sendbuffer = ByteBuffer.allocate(1024);
  5.     /*发送数据缓冲区*/
  6.     private  ByteBuffer receivebuffer = ByteBuffer.allocate(1024);

  8.     private Selector selector;

  10.     public NIOServer(int port) throws IOException {
  11.         // 打开服务器套接字通道
  12.         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
  13.         // 服务器配置为非阻塞
  14.         serverSocketChannel.configureBlocking(false);
  15.         // 检索与此通道关联的服务器套接字
  16.         ServerSocket serverSocket = serverSocketChannel.socket();
  17.         // 进行服务的绑定
  18.         serverSocket.bind(new InetSocketAddress(port));
  19.         // 通过open()方法找到Selector
  20.         selector = Selector.open();
  21.         // 注册到selector，等待连接
  22.         serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
  23.         System.out.println("Server Start----:");
  24.     }

  26.     //
  27.     private void listen() throws IOException {
  28.         while (true) {
  29.             selector.select();
  30.             Set<SelectionKey> selectionKeys = selector.selectedKeys();
  31.             Iterator<SelectionKey> iterator = selectionKeys.iterator();
  32.             while (iterator.hasNext()) {
  33.                 SelectionKey selectionKey = iterator.next();
  34.                 iterator.remove();
  35.                 handleKey(selectionKey);
  36.             }
  37.         }
  38.     }

  40.     private void handleKey(SelectionKey selectionKey) throws IOException {
  41.         // 接受请求
  42.         ServerSocketChannel server = null;
  43.         SocketChannel client = null;
  44.         String receiveText;
  45.         String sendText;
  46.         int count=0;
  47.         // 测试此键的通道是否已准备好接受新的套接字连接。
  48.         if (selectionKey.isAcceptable()) {
  49.             // 返回为之创建此键的通道。
  50.             server = (ServerSocketChannel) selectionKey.channel();
  51.             // 接受到此通道套接字的连接。
  52.             // 此方法返回的套接字通道（如果有）将处于阻塞模式。
  53.             client = server.accept();
  54.             // 配置为非阻塞
  55.             client.configureBlocking(false);
  56.             // 注册到selector，等待连接
  57.             client.register(selector, SelectionKey.OP_READ);
  58.         } else if (selectionKey.isReadable()) {
  59.             // 返回为之创建此键的通道。
  60.             client = (SocketChannel) selectionKey.channel();
  61.             //将缓冲区清空以备下次读取
  62.             receivebuffer.clear();
  63.             //读取服务器发送来的数据到缓冲区中
  64.             count = client.read(receivebuffer);
  65.             if (count > 0) {
  66.                 receiveText = new String( receivebuffer.array(),0,count);
  67.                 System.out.println("服务器端接受客户端数据--:"+receiveText);
  68.                 client.register(selector, SelectionKey.OP_WRITE);
  69.             }
  70.         } else if (selectionKey.isWritable()) {
  71.             //将缓冲区清空以备下次写入
  72.             sendbuffer.clear();
  73.             // 返回为之创建此键的通道。
  74.             client = (SocketChannel) selectionKey.channel();
  75.             sendText="message from server--";
  76.             //向缓冲区中输入数据
  77.             sendbuffer.put(sendText.getBytes());
  78.             //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位
  79.             sendbuffer.flip();
  80.             //输出到通道
  81.             client.write(sendbuffer);
  82.             System.out.println("服务器端向客户端发送数据--："+sendText);
  83.             client.register(selector, SelectionKey.OP_READ);
  84.         }
  85.     }

  87.     /**
  88.     * @param args
  89.     * @throws IOException
  90.     */
  91.     public static void main(String[] args) throws IOException {
  92.         int port = 8080;
  93.         NIOServer server = new NIOServer(port);
  94.         server.listen();
  95.     }
  96. }
 

客户端
 

 

  1. public class NIOClient {
  2.     /*接受数据缓冲区*/
  3.     private static ByteBuffer sendbuffer = ByteBuffer.allocate(1024);
  4.     /*发送数据缓冲区*/
  5.     private static ByteBuffer receivebuffer = ByteBuffer.allocate(1024);

  7.     public static void main(String[] args) throws IOException {
  8.         // 打开socket通道
  9.         SocketChannel socketChannel = SocketChannel.open();
  10.         // 设置为非阻塞方式
  11.         socketChannel.configureBlocking(false);
  12.         // 打开选择器
  13.         Selector selector = Selector.open();
  14.         // 注册连接服务端socket动作
  15.         socketChannel.register(selector, SelectionKey.OP_CONNECT);
  16.         // 连接
  17.         socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));

  19.         Set<SelectionKey> selectionKeys;
  20.         Iterator<SelectionKey> iterator;
  21.         SelectionKey selectionKey;
  22.         SocketChannel client;
  23.         String receiveText;
  24.         String sendText;
  25.         int count=0;

  27.         while (true) {
  28.             //选择一组键，其相应的通道已为 I/O 操作准备就绪。
  29.             //此方法执行处于阻塞模式的选择操作。
  30.             selector.select();
  31.             //返回此选择器的已选择键集。
  32.             selectionKeys = selector.selectedKeys();
  33.             //System.out.println(selectionKeys.size());
  34.             iterator = selectionKeys.iterator();
  35.             while (iterator.hasNext()) {
  36.                 selectionKey = iterator.next();
  37.                 if (selectionKey.isConnectable()) {
  38.                     System.out.println("client connect");
  39.                     client = (SocketChannel) selectionKey.channel();
  40.                     // 判断此通道上是否正在进行连接操作。
  41.                     // 完成套接字通道的连接过程。
  42.                     if (client.isConnectionPending()) {
  43.                         client.finishConnect();
  44.                         System.out.println("完成连接!");
  45.                         sendbuffer.clear();
  46.                         sendbuffer.put("Hello,Server".getBytes());
  47.                         sendbuffer.flip();
  48.                         client.write(sendbuffer);
  49.                     }
  50.                     client.register(selector, SelectionKey.OP_READ);
  51.                 } else if (selectionKey.isReadable()) {
  52.                     client = (SocketChannel) selectionKey.channel();
  53.                     //将缓冲区清空以备下次读取
  54.                     receivebuffer.clear();
  55.                     //读取服务器发送来的数据到缓冲区中
  56.                     count=client.read(receivebuffer);
  57.                     if(count>0){
  58.                         receiveText = new String( receivebuffer.array(),0,count);
  59.                         System.out.println("客户端接受服务器端数据--:"+receiveText);
  60.                         client.register(selector, SelectionKey.OP_WRITE);
  61.                     }

  63.                 } else if (selectionKey.isWritable()) {
  64.                     sendbuffer.clear();
  65.                     client = (SocketChannel) selectionKey.channel();
  66.                     sendText = "message from client--";
  67.                     sendbuffer.put(sendText.getBytes());
  68.                     //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位
  69.                     sendbuffer.flip();
  70.                     client.write(sendbuffer);
  71.                     System.out.println("客户端向服务器端发送数据--："+sendText);
  72.                     client.register(selector, SelectionKey.OP_READ);
  73.                 }
  74.             }
  75.             selectionKeys.clear();
  76.         }
  77.     }
  78. }
 

运行结果
 

 


                

        

        

    

  


    


                



	

		

			

				
					
NIO学习

				
			

			

				

					weixin_41786712的博客
				

				

					05-19
					
					270
					
				

			

		

		

			
				
4.NIO
4.1 NIO的概念
NIO是NO Blocking IO的缩写，它的交互方式是同步非阻塞的方式。
4.2 BIO的特点
程序的IO操作的完成的状态是一致的，即便某个连接的读写动作未完成(如数据未准备就绪)，也不会阻塞其它连接的读写动作。相对BIO而言，NIO具有效率高，但由于频繁的切换线程上下文，会影响CPU性能的特点。
4.3 NIO的重要组件
Channel(通道)、Buffer(缓冲区)、Selector(多路复用器)是NIO的三元素，也是最重要的组件。实现原理，它只需两个线程就能实现，

			
		

	



                

            
              



	

		

			

				
					
nio学习

				
			

			

				

					huihuishou_su的博客
				

				

					05-17
					
					157
					
				

			

		

		

			
				
Nio

			
		

	



              


  
              

                


	

		

			

				
					
NIO基础

					
最新发布

				
			

			

				

					我的博客
				

				

					09-28
					
					1201
					
				

			

		

		

			
				
这样，一个单独的线程可以通过轮询 Selector 来判断一组 Channel 是否有就绪状态的事件，从而只需要少量的线程就能处理大量的客户端请求。，可以从 channel 将数据读入 buffer，也可以将 buffer 的数据写入 channel，而之前的 stream 要么是输入，要么是输出，channel 比 stream 更为底层。它与数组类似，但是提供了对数据的结构化访问，并且可以跟踪已经读写了多少数据。Buffer 是一块可以写入数据，然后可以从中读取数据的内存块。

			
		

	





	

		

			

				
					
nio 学习

				
			

			

				

					sprita1的专栏
				

				

					01-27
					
					944
					
				

			

		

		

			
				
io与nio区别：
io是面向流的，  nio是面向缓冲区的(速度快)
io是线程阻塞的，nio是线程非阻塞的，所以在nio中一个单独的线程可以处理多个输入和输出通道（channel）的操作




服务端：
selector： 
channel_1(key的属性为accept) —— 对应 socket_1 
循环遍历key建立与客户端连接
>-返回key 
channe

			
		

	



		

			
		



	

		

			

				
					
Java NIO原理图文分析及代码实现  

				
			

			

				

					lvwenwen
				

				

					04-11
					
					434
					
				

			

		

		

			
				
Java NIO原理图文分析及代码实现 
前言: 
文章链接:http://weixiaolu.iteye.com/blog/1479656
最近在分析hadoop的RPC(Remote Procedure Call Protocol ，远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。可以参考：http://baike.baidu.com/vie...

			
		

	





	

		

			

				
					
JAVA IO-NIO 详解

				
			

			

				

					04-24
				

			

		

		

			
				
### JAVA IO-NIO 详解  #### 一、IO与NIO概述  在Java开发中，输入/输出（IO）操作是程序与外部环境交互的重要环节。通过IO操作，程序可以读取外部数据或向外部环境输出数据。Java的IO体系自Java 1.0以来就一直存在...

			
		

	





	

		

			

				
					
Java NIO基础与异步IO详解

				
			

			

				

					
				

			

		

		

			
				
1. **NIO基础知识**:  - NIO的核心概念包括Buffer（缓冲区）、Channel（通道）和Selector（选择器）。Buffer是数据的临时存储区域，可以存储原始数据，并支持高效的数据读取和写入。Channel是数据传输的抽象通道，...

			
		

	





	

		

			

				
					
NIO基础了解

				
			

			

				

					g5703129的博客
				

				

					12-17
					
					123
					
				

			

		

		

			
				
是jdk1.4出现的新的流.

BIO - Blocking IO - 同步式阻塞式IO --- UDP/TCP

NIO - New  IO - 同步式非阻塞式IO

AIO  - AsynchronousIO - 异步式非阻塞式IO - jdk1.8

BIO的缺点:

会产生阻塞行为 --- receive/accept/connect/read/write
	一对一的连接:每连接一个客户端...

			
		

	





	

		

			

				
					
Tomcat基础镜像优化全攻略：内存调优与NIO技术详解

				
			

			

				

					
				

			

		

		

			
				
本资源是一份详细的Tomcat基础镜像优化手册，针对Tomcat 8.5及以上版本进行讲解。主要内容涵盖了以下几个关键方面：  1. **JDK选项优化** (JDKOPTS)：指南首先介绍了如何通过在`catalina.sh`脚本中添加`JAVA_OPTS`来...

			
		

	





	

		

			

				
					
NIO基础介绍（一）

				
			

			

				

					liuzewei2015的博客
				

				

					07-02
					
					211
					
				

			

		

		

			
				
（1）Java.io中最为核心的一个概念是流（stream），面向流的编程。流是信息的载体。Java中一个流要么是输入流，要么是输出流，不可能同时既是输入流又是输出流。

（2）Java.nio中拥有3个核心概念：selector，channel，buffer。在java.nio中是面向块（block）或是缓冲区（buffer）编程的。Buffer本身就是一块内存，底层实现上，它实际上是个数组。数...

			
		

	





	

		

			

				
					
JAVA NIO通信基础详解

				
			

			

				

					pys52055的博客
				

				

					02-16
					
					148
					
				

			

		

		

			
				
NIO（non-Block IO)和OIO(Old IO)对比
（1） OIO是面向流的，NIO是面向缓冲区的.OIO是面向字节流或者字符流的，以流式的方式从一个流中读取一个或者多个字节，因此不能随意改变读取指针的位置。NIO引入了Channel(通道)和Buffer(缓冲区)的概念。只需从通道读取数据到缓冲区或者从缓冲区写到通道中，可以随意的读取缓冲区的任意位置数据。



...

			
		

	





	

		

			

				
					
nio详解

				
			

			

				

					weixin_45032905的博客
				

				

					02-28
					
					562
					
				

			

		

		

			
				
聊聊nio
bio叫做同步阻塞的io模型, 数据的读取和写入必须阻塞在一个线程里面, 等待完成, 也就是说, 当连接数不是很高, 例如说, 只有不到1000的连接数的这么一个情况的时候, 这种模型是很不错的, 可以让每一个连接都专注于自己的一个io, 并且编码简单, 更不用去考虑系统的一个过载和限流的问题, 更何况线程池本身就有等待和缓冲的这么一个作用, 连接量不高的情况下是可以兼顾性能和连接量的.
但是当我们的连接数一旦大的时候, 传统的bio模型是十分无力的.
nio, 叫做同步非阻塞的这么一个io模型

			
		

	





	

		

			

				
					
NIO  学习

				
			

			

				

					baiguang1234的博客
				

				

					02-27
					
					177
					
				

			

		

		

			
				
IO和NIO 区别：
1. IO面向流（stream）,流是单向的，NIO面向的是（buffer），管道（channel）双向的。
2. IO是阻塞式，NIO是非阻塞式的（NIO多了一个选择器（selector））


缓冲区类型：
ByteBuffer/CharBuffer/ShortBuffer/IntBuffer/LongBuffer/FloatBuffer/DoubleBuffer

缓...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值