AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

java nio 操作（2）异步阻塞 socket实现

2017-01-06 1982
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 一.同步阻塞IO         BIO就是阻塞式的IO，网络通信中对于多客户端的连入，服务器端总是与客户端数量一致的线程去处理每个客户端任务，即，客户端与线程数1:1，并且进行读写操作室阻塞的，当有你成千上完的客户端进行连接，就导致服务器不断的建立新的线程，最后导致低通资源不足，后面的客户端不能连接服务器，并且连接入的客户端并不是总是在于服务器进行交互，很可能就只是占用着资源而已。

一.同步阻塞IO

        BIO就是阻塞式的IO，网络通信中对于多客户端的连入，服务器端总是与客户端数量一致的线程去处理每个客户端任务，即，客户端与线程数1:1，并且进行读写操作室阻塞的，当有你成千上完的客户端进行连接，就导致服务器不断的建立新的线程，最后导致低通资源不足，后面的客户端不能连接服务器，并且连接入的客户端并不是总是在于服务器进行交互，很可能就只是占用着资源而已。

二.伪异步IO

   伪异步IO对同步IO进行了优化，后端通过一个线程池和任务队列去处理所有客户端的请求，当用完后在归还给线程池，线程池的原理和数据库连接池的原理很像，他减少了线程创建和销毁的时间，无论多少客户端的连接都是这些固定的线程数量去处理，这在大量客户端与服务器信息交互量很少的情况下，是一种很好的处理方式，但是想一种情况，当有一个客户端的读取信息非常慢时，服务器对其的写操作时会很慢，甚至会阻塞很长时间，因为线程池中的线程是有限的，当有客户端需要分配线程时，就会导致新任务在队列中一直等待阻塞的客户端释放线程。当任务队列已经满时，就会有大量的用户发生连接超时。其实，伪异步IO也是同步阻塞IO。


三.javaNIO原理

       为了解决上面的两种阻塞IO的缺陷，Java在1.4版本开始加入NIO也称为new IO，至于他是什么模型我们先来看这个博客（Java NIO BIO AIO全面剖析）。看完之后就会很清楚了。


目前在UNP划分的角度，异步IO只有AIO。网络通信中，NIO也提供了SocketChannel和ServerSocketChannel两种不同的套接字通道来实现，可以设置阻塞余非阻塞两种模式，为了实现高负载高并发都采取非阻塞的模式。NIO采用缓冲区BUFFER，实现对数据的读写操作，缓冲区是固定大小，并由内部状态记录有多少数据被放入或者取出。与阻塞IO不同，阻塞IO采用阻塞式流（Stream）的方式进行读写，流是单向的只能向一个方向读数据或者写数据，而通道是双向的，可以同时在通道上发送和读取数据，而且是非阻塞的，在没有数据可读可写时可以去做别的事情。

       NIO改进了上面的一对一或者M：N的模型。服务器仅采用一个一个线程去处理所有客户端线程，这就需要创建一个selector，并将其注册到想要监控的信道上（注意是通过channel的方法来实现），并返回一个selectorKey实例（包含通道和select以及感兴趣的操作），selector就好像是一个观察者，通过不断轮询所注册的一组通道上有没有等待的操作发生，当等待事件发生的时候可以做其他事情，当有信道出现感兴趣的操作，则该信道就进入就绪状态。

      Slector的select方法阻塞等待又没有就绪的通道，当出现就绪的信道或者等待超时返回，就绪信道的个数，若等待超时则返回-1，selectedKeys方法返回就绪的信道。

   下面附代码

这是处理感兴趣信道的接口，因为他可以放在多个服务器上所以把他做成了接口。

[java] view plain copy
  1. package Nio;  
  2.   
  3. import java.io.IOException;  
  4. import java.nio.channels.SelectionKey;  
  5.   
  6. public interface TCPProtocol {  
  7.     void handleAccept(SelectionKey key) throws IOException;  
  8.     void handleRead(SelectionKey key) throws IOException;  
  9.     void handleWrite(SelectionKey key) throws IOException;  
  10. }  
[java] view plain copy
  1. <span style="font-family:FangSong_GB2312;">这是对上面接口的具体实现</span>  
  2. package Nio;  
  3.   
  4. import java.io.IOException;  
  5. import java.nio.ByteBuffer;  
  6. import java.nio.channels.SelectionKey;  
  7. import java.nio.channels.ServerSocketChannel;  
  8. import java.nio.channels.SocketChannel;  
  9.   
  10. public class SelectorProtocol implements TCPProtocol {  
  11.     private int bufSize ;  
  12.     public SelectorProtocol(int buffsize){  
  13.         this.bufSize = buffsize;  
  14.     }  
  15.   
  16.      //服务端信道已经准备好了接收新的客户端连接    
  17.     public void handleAccept(SelectionKey key) throws IOException {    
  18.         SocketChannel clntChan = ((ServerSocketChannel) key.channel()).accept();    
  19.         clntChan.configureBlocking(false);    
  20.         //将选择器注册到连接到的客户端信道，并指定该信道key值的属性为OP_READ，同时为该信道指定关联的附件    
  21.         clntChan.register(key.selector(), SelectionKey.OP_READ, ByteBuffer.allocate(bufSize));    
  22.     }    
  23.     
  24.     //客户端信道已经准备好了从信道中读取数据到缓冲区    
  25.     public void handleRead(SelectionKey key) throws IOException{    
  26.         SocketChannel clntChan = (SocketChannel) key.channel();    
  27.         //获取该信道所关联的附件，这里为缓冲区    
  28.         ByteBuffer buf = (ByteBuffer) key.attachment();    
  29.         long bytesRead = clntChan.read(buf);    
  30.         //如果read（）方法返回-1，说明客户端关闭了连接，那么客户端已经接收到了与自己发送字节数相等的数据，可以安全地关闭    
  31.         if (bytesRead == -1){     
  32.             clntChan.close();    
  33.         }else if(bytesRead > 0){    
  34.         //如果缓冲区总读入了数据，则将该信道感兴趣的操作设置为为可读可写    
  35.         key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);    
  36.         }    
  37.     }    
  38.         
  39.     //客户端信道已经准备好了将数据从缓冲区写入信道    
  40.     public void handleWrite(SelectionKey key) throws IOException {    
  41.     //获取与该信道关联的缓冲区，里面有之前读取到的数据    
  42.     ByteBuffer buf = (ByteBuffer) key.attachment();    
  43.     //重置缓冲区，准备将数据写入信道    
  44.     buf.flip();     
  45.     SocketChannel clntChan = (SocketChannel) key.channel();    
  46.     //将数据写入到信道中    
  47.     clntChan.write(buf);    
  48.     if (!buf.hasRemaining()){     
  49.     //如果缓冲区中的数据已经全部写入了信道，则将该信道感兴趣的操作设置为可读    
  50.       key.interestOps(SelectionKey.OP_READ);    
  51.     }    
  52.     //为读入更多的数据腾出空间    
  53.     buf.compact();     
  54.   }    
  55. }  
客户端

[java] view plain copy
  1. package Nio;  
  2. import java.net.InetSocketAddress;  
  3. import java.net.SocketException;  
  4. import java.nio.ByteBuffer;  
  5. import java.nio.channels.SocketChannel;  
  6.   
  7. public class TCPEchoClientNonblocking {  
  8.     public static void main(String args[]) throws Exception{  
  9.         //第一个参数作为要连接的服务端的主机名或IP  
  10.         String server = "localhost";   
  11.         //第二个参数为要发送到服务端的字符串  
  12.         byte[] argument = "nihaopengyou".getBytes();  
  13.         //如果有第三个参数，则作为端口号，如果没有，则端口号设为7  
  14.         int servPort = 2002;  
  15.         //创建一个信道，并设为非阻塞模式  
  16.         SocketChannel clntChan = SocketChannel.open();  
  17.         clntChan.configureBlocking(false);  
  18.         //向服务端发起连接  
  19.         if (!clntChan.connect(new InetSocketAddress(server, servPort))){  
  20.             //不断地轮询连接状态，直到完成连接  
  21.             while (!clntChan.finishConnect()){  
  22.                 //在等待连接的时间里，可以执行其他任务，以充分发挥非阻塞IO的异步特性  
  23.                 //这里为了演示该方法的使用，只是一直打印"."  
  24.                 System.out.print(".");    
  25.             }  
  26.         }  
  27.         //为了与后面打印的"."区别开来，这里输出换行符  
  28.         System.out.print("\n");  
  29.         //分别实例化用来读写的缓冲区  
  30.         ByteBuffer writeBuf = ByteBuffer.wrap(argument);  
  31.         ByteBuffer readBuf = ByteBuffer.allocate(argument.length);  
  32.         //接收到的总的字节数  
  33.         int totalBytesRcvd = 0;   
  34.         //每一次调用read（）方法接收到的字节数  
  35.         int bytesRcvd;   
  36.         //循环执行，直到接收到的字节数与发送的字符串的字节数相等  
  37.         while (totalBytesRcvd < argument.length){  
  38.             //如果用来向通道中写数据的缓冲区中还有剩余的字节，则继续将数据写入信道  
  39.             if (writeBuf.hasRemaining()){  
  40.                 clntChan.write(writeBuf);  
  41.             }  
  42.             //如果read（）接收到-1，表明服务端关闭，抛出异常  
  43.             if ((bytesRcvd = clntChan.read(readBuf)) == -1){  
  44.                 throw new SocketException("Connection closed prematurely");  
  45.             }  
  46.             //计算接收到的总字节数  
  47.             totalBytesRcvd += bytesRcvd;  
  48.             //在等待通信完成的过程中，程序可以执行其他任务，以体现非阻塞IO的异步特性  
  49.             //这里为了演示该方法的使用，同样只是一直打印"."  
  50.             System.out.print(".");   
  51.         }  
  52.         //打印出接收到的数据  
  53.         System.out.println("Received: " +  new String(readBuf.array(), 0, totalBytesRcvd));  
  54.         //关闭信道  
  55.         clntChan.close();  
  56.     }  
  57. }  

服务器

[java] view plain copy
  1. package Nio;  
  2. import java.io.IOException;  
  3. import java.net.InetSocketAddress;  
  4. import java.nio.channels.SelectionKey;  
  5. import java.nio.channels.Selector;  
  6. import java.nio.channels.ServerSocketChannel;  
  7. import java.util.Iterator;  
  8.   
  9. public class TCPServerSelector{  
  10.     //缓冲区的长度  
  11.     private static final int BUFSIZE = 256;   
  12.     //select方法等待信道准备好的最长时间  
  13.     private static final int TIMEOUT = 3000;   
  14.     public static void main(String[] args) throws IOException {  
  15.         if (args.length < 1){  
  16.             throw new IllegalArgumentException("Parameter(s): <Port> ...");  
  17.         }  
  18.         //创建一个选择器  
  19.         Selector selector = Selector.open();  
  20.         for (String arg : args){  
  21.             //实例化一个信道  
  22.             ServerSocketChannel listnChannel = ServerSocketChannel.open();  
  23.             //将该信道绑定到指定端口  
  24.             listnChannel.socket().bind(new InetSocketAddress(Integer.parseInt(arg)));  
  25.             System.out.println("启动服务器"+Integer.parseInt(arg));  
  26.             //配置信道为非阻塞模式  
  27.             listnChannel.configureBlocking(false);  
  28.             //将选择器注册到各个信道  
  29.             listnChannel.register(selector, SelectionKey.OP_ACCEPT);  
  30.         }  
  31.         //创建一个实现了协议接口的对象  
  32.         TCPProtocol protocol = new SelectorProtocol(BUFSIZE);  
  33.         //不断轮询select方法，获取准备好的信道所关联的Key集  
  34.         while (true){  
  35.             //一直等待,直至有信道准备好了I/O操作  
  36.             if (selector.select(TIMEOUT) == 0){  
  37.                 //在等待信道准备的同时，也可以异步地执行其他任务，  
  38.                 //这里只是简单地打印"."  
  39.                 System.out.print(".");  
  40.                 continue;  
  41.             }  
  42.             //获取准备好的信道所关联的Key集合的iterator实例  
  43.             Iterator<SelectionKey> keyIter = selector.selectedKeys().iterator();  
  44.             //循环取得集合中的每个键值  
  45.             while (keyIter.hasNext()){  
  46.                 SelectionKey key = keyIter.next();   
  47.                 //如果服务端信道感兴趣的I/O操作为accept  
  48.                 if (key.isAcceptable()){  
  49.                     protocol.handleAccept(key);  
  50.                 }  
  51.                 //如果客户端信道感兴趣的I/O操作为read  
  52.                 if (key.isReadable()){  
  53.                     protocol.handleRead(key);  
  54.                 }  
  55.                 //如果该键值有效，并且其对应的客户端信道感兴趣的I/O操作为write  
  56.                 if (key.isValid() && key.isWritable()) {  
  57.                     protocol.handleWrite(key);  
  58.                 }  
  59.                 //这里需要手动从键集中移除当前的key  
  60.                 keyIter.remove();   
  61.             }  
  62.         }  
  63.     }  
  64. }  

运行结果：
文章标签：
Java
监控
数据库
关键词：
Java NIO
Java异步
Java Socket
Java阻塞
Java操作
lhyxcxy
目录
相关文章
蓝易云
|
2天前
|
存储 监控 Java
Java的NIO体系
通过本文的介绍，希望您能够深入理解Java NIO体系的核心组件、工作原理及其在高性能应用中的实际应用，并能够在实际开发中灵活运用这些知识，构建高效的Java应用程序。
蓝易云
19 5
勇哥Java实战
|
1月前
|
消息中间件 缓存 Java
java nio，netty，kafka 中经常提到“零拷贝”到底是什么？
零拷贝技术 Zero-Copy 是指计算机执行操作时，可以直接从源（如文件或网络套接字）将数据传输到目标缓冲区， 而不需要 CPU 先将数据从某处内存复制到另一个特定区域，从而减少上下文切换以及 CPU 的拷贝时间。
勇哥Java实战
61 0
java nio，netty，kafka 中经常提到“零拷贝”到底是什么？
武子康
|
2月前
|
Java 流计算
Flink-03 Flink Java 3分钟上手 Stream 给 Flink-02 DataStreamSource Socket写一个测试的工具！
Flink-03 Flink Java 3分钟上手 Stream 给 Flink-02 DataStreamSource Socket写一个测试的工具！
武子康
45 1
Flink-03 Flink Java 3分钟上手 Stream 给 Flink-02 DataStreamSource Socket写一个测试的工具！
进步`于辰
|
2月前
|
Java
[Java]Socket套接字（网络编程入门）
本文介绍了基于Java Socket实现的一对一和多对多聊天模式。一对一模式通过Server和Client类实现简单的消息收发；多对多模式则通过Server类维护客户端集合，并使用多线程实现实时消息广播。文章旨在帮助读者理解Socket的基本原理和应用。
进步`于辰
29 1
Dylaniou
|
2月前
|
Java
让星星⭐月亮告诉你，Java NIO之Buffer详解 属性capacity/position/limit/mark 方法put(X)/get()/flip()/compact()/clear()
这段代码演示了Java NIO中`ByteBuffer`的基本操作，包括分配、写入、翻转、读取、压缩和清空缓冲区。通过示例展示了`position`、`limit`和`mark`属性的变化过程，帮助理解缓冲区的工作原理。
Dylaniou
35 2
2G冲浪词条
|
3月前
|
存储 网络协议 Java
Java NIO 开发
本文介绍了Java NIO（New IO）及其主要组件，包括Channel、Buffer和Selector，并对比了NIO与传统IO的优势。文章详细讲解了FileChannel、SocketChannel、ServerSocketChannel、DatagramChannel及Pipe.SinkChannel和Pipe.SourceChannel等Channel实现类，并提供了示例代码。通过这些示例，读者可以了解如何使用不同类型的通道进行数据读写操作。
2G冲浪词条
66 0
Java NIO 开发
Java开发者
|
2月前
|
网络协议 安全 Java
Java Socket原理
Java Socket原理是指在Java中通过Socket实现的网络通信的基础理论与机制。Socket是网络中不同设备间通信的一种标准方式，它允许应用程序之间通过TCP/IP等协议进行数据交换。在Java中，利用Socket编程可以方便地创建客户端与服务器端应用，实现跨网络的数据传输功能，是互联网软件开发中的重要技术之一。它支持多种通信模式，如可靠的流式套接字（TCP）和数据报式套接字（UDP）。
Java开发者
58 10
土木林森
|
4月前
|
Java
"揭秘Java IO三大模式：BIO、NIO、AIO背后的秘密！为何AIO成为高并发时代的宠儿，你的选择对了吗？"
【8月更文挑战第19天】在Java的IO编程中，BIO、NIO与AIO代表了三种不同的IO处理机制。BIO采用同步阻塞模型，每个连接需单独线程处理，适用于连接少且稳定的场景。NIO引入了非阻塞性质，利用Channel、Buffer与Selector实现多路复用，提升了效率与吞吐量。AIO则是真正的异步IO，在JDK 7中引入，通过回调或Future机制在IO操作完成后通知应用，适合高并发场景。选择合适的模型对构建高效网络应用至关重要。
土木林森
93 2
土木林森
|
4月前
|
网络协议 C# 开发者
WPF与Socket编程的完美邂逅：打造流畅网络通信体验——从客户端到服务器端，手把手教你实现基于Socket的实时数据交换
【8月更文挑战第31天】网络通信在现代应用中至关重要，Socket编程作为其实现基础，即便在主要用于桌面应用的Windows Presentation Foundation（WPF）中也发挥着重要作用。本文通过最佳实践，详细介绍如何在WPF应用中利用Socket实现网络通信，包括创建WPF项目、设计用户界面、实现Socket通信逻辑及搭建简单服务器端的全过程。具体步骤涵盖从UI设计到前后端交互的各个环节，并附有详尽示例代码，助力WPF开发者掌握这一关键技术，拓展应用程序的功能与实用性。
土木林森
146 0
蓝易云
|
5月前
|
存储 Java 索引
Java ArrayList操作指南：如何移除并返回第一个元素
通过上述方法，你可以方便地从Java的 `ArrayList` 中移除并返回第一个元素。这种操作在日常编程中非常常见，是处理列表时的基本技能之一。希望这篇指南能帮助你更好地理解和运用Java的 `ArrayList`。
蓝易云
59 4

热门文章

最新文章

  • 1
    【Java】留下没有基础眼泪的面试题
  • 2
    java报错javax.net.ssl.SSLHandshakeException:  sun.security.validator.ValidatorException
  • 3
    Java-学习笔记-8-接口
  • 4
    Java Servlet Cookie 详解
  • 5
    Java 枚举类型使用小技巧
  • 6
    超简单的java爬虫
  • 7
    走出Java资源加载的迷宫
  • 8
    【Java虚拟机】JVM诊断神器Arthas入门实操
  • 9
    用 Java Servlet 实现文件上载（老文新发）
  • 10
    Java Poi 创建与读取Excel
  • 1
    2024-03-27 16:24:05.811 ERROR [nio-9603-exec-2] c.t.t.handler.GlobalExceptionHandler
    95
  • 2
    Java NIO和IO之间的区别
    68
  • 3
    Elasticsearch【问题记录 01】启动服务&停止服务的2类方法【及 java.nio.file.AccessDeniedException: xx/pid 问题解决】（含shell脚本文件）
    699
  • 4
    深入理解 Java 网络编程和 NIO
    78
  • 5
    浅谈Java NIO
    40
  • 6
    【Java NIO】那NIO为什么速度快？
    93
  • 7
    Java输入输出：什么是NIO（New I/O）？
    57
  • 8
    SpringBoot 运行出现java.nio.charset.MalformedInputException: Input length = 1
    133
  • 9
    启动报错：java.nio.charset.MalformedInputException: Input length = 1
    113
  • 10
    Java的IO技术和NIO技术
    92

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    fs.oss.accessKeyId和fs.oss.accessKeySecret。