基于事件的 NIO 多线程服务器


文章链接:http://www.ibm.com/developerworks/cn/java/l-niosvr/#4

              http://shenxueliang.iteye.com/blog/1677174


JDK1.4 的 NIO 有效解决了原有流式 IO 存在的线程开销的问题,在 NIO 中使用多线程,主要目的已不是为了应对每个客户端请求而分配独立的服务线程,而是通过多线程充分使用用多个 CPU 的处理能力和处理中的等待时间,达到提高服务能力的目的。 

多线程的引入,容易为本来就略显复杂的 NIO 代码进一步降低可读性和可维护性。引入良好的设计模型,将不仅带来高性能、高可靠的代码,也将带来一个惬意的开发过程。

线程模型

NIO 的选择器采用了多路复用(Multiplexing)技术,可在一个选择器上处理多个套接字, 通过获取读写通道来进行 IO 操作。由于网络带宽等原因,在通道的读、写操作中是容易出现等待的, 所以在读、写操作中引入多线程,对性能提高明显,而且可以提高客户端的感知服务质量。所以本文的模型将主要通过使用读、写线程池 来提高与客户端的数据交换能力。

如下图所示,服务端接受客户端请求后,控制线程将该请求的读通道交给读线程池,由读线程池分配线程完成对客户端数据的读取操作;当读线程完成读操作后,将数据返回控制线程,进行服务端的业务处理;完成 业务处理后,将需回应给客户端的数据和写通道提交给写线程池,由写线程完成向客户端发送回应数据的操作。


(NIO 多线程服务器模型)
 

同时整个服务端的流程处理,建立于事件机制上。在 [接受连接->读->业务处理->写 ->关闭连接 ]这个 过程中,触发器将触发相应事件,由事件处理器对相应事件分别响应,完成服务器端的业务处理。 
下面我们就来详细看一下这个模型的各个组成部分。

相关事件定义 在这个模型中,我们定义了一些基本的事件:

(1)onAccept:当服务端收到客户端连接请求时,触发该事件。通过该事件我们可以知道有新的客户端呼入。该事件可用来控制服务端的负载。例如,服务器可设定同时只为一定数量客户端提供服务,当同时请求数超出数量时,可在响应该事件时直接抛出异常,以拒绝新的连接。 

(2)onAccepted:当客户端请求被服务器接受后触发该事件。该事件表明一个新的客户端与服务器正式建立连接。 

(3)onRead:当客户端发来数据,并已被服务器控制线程正确读取时,触发该事件 。该事件通知各事件处理器可以对客户端发来的数据进行实际处理了。需要注意的是,在本模型中,客户端的数据读取是由控制线程交由读线程完成的,事件处理器不需要在该事件中进行专门的读操作,而只需将控制线程传来的数据进行直接处理即可。 

(4)onWrite:当客户端可以开始接受服务端发送数据时触发该事件,通过该事件,我们可以向客户端发送回应数据。 在本模型中,事件处理器只需要在该事件中设置 

(5)onClosed:当客户端与服务器断开连接时触发该事件。 

(6)onError:当客户端与服务器从连接开始到最后断开连接期间发生错误时触发该事件。通过该事件我们可以知道有什么错误发生。 

事件回调机制的实现

在这个模型中,事件采用广播方式,也就是所有在册的事件处理器都能获得事件通知。这样可以将不同性质的业务处理,分别用不同的处理器实现,使每个处理器的业务功能尽可能单一。 
如下图:整个事件模型由监听器、事件适配器、事件触发器、事件处理器组成。


(事件模型)
 

  1. 监听器(Serverlistener):这是一个事件接口,定义需监听的服务器事件,如果您需要定义更多的事件,可在这里进行扩展。 
    	 public interface Serverlistener { 
       public void onError(String error); 
       public void onAccept() throws Exception; 
       public void onAccepted(Request request) throws Exception; 
       public void onRead(Request request) throws Exception; 
       public void onWrite(Request request, Response response) throws Exception; 
       public void onClosed(Request request) throws Exception; 
     }

  2. 事件适配器(EventAdapter):对 Serverlistener 接口实现一个适配器 (EventAdapter),这样的好处是最终的事件处理器可以只处理所关心的事件。 
     public abstract class EventAdapter implements Serverlistener { 
        public EventAdapter() { 
        } 
        public void onError(String error) {} 
        public void onAccept() throws Exception {} 
        public void onAccepted(Request request)  throws Exception {} 
        public void onRead(Request request)  throws Exception {} 
        public void onWrite(Request request, Response response)  throws Exception {} 
        public void onClosed(Request request)  throws Exception {} 
     }   
    

  3. 事件触发器(Notifier):用于在适当的时候通过触发服务器事件,通知在册的事件处理器对事件做出响应。触发器以 Singleton 模式实现,统一控制整个服务器端的事件,避免造成混乱。 
    public class Notifier { 
        private static Arraylist listeners = null; 
        private static Notifier instance = null; 
        private Notifier() { 
            listeners = new Arraylist(); 
        } 
        /** 
         * 获取事件触发器
         * @return 返回事件触发器
         */ 
        public static synchronized Notifier getNotifier() { 
            if (instance == null) { 
                instance = new Notifier(); 
                return instance; 
            } 
            else return instance; 
        } 
        /** 
         * 添加事件监听器
         * @param l 监听器
         */ 
        public void addlistener(Serverlistener l) { 
            synchronized (listeners) { 
                if (!listeners.contains(l)) 
                    listeners.add(l); 
            } 
        } 
        public void fireOnAccept() throws Exception { 
            for (int i = listeners.size() - 1; i >= 0; i--) 
                ( (Serverlistener) listeners.get(i)).onAccept(); 
        } 
        ....// other fire method 
     } 
    

  4. 事件处理器(Handler):继承事件适配器,对感兴趣的事件进行响应处理,实现业务处理。以下是一个简单的事件处理器实现,它响应 onRead 事件,在终端打印出从客户端读取的数据。 
     public class ServerHandler extends EventAdapter { 
        public ServerHandler() { 
        } 
        public void onRead(Request request) throws Exception { 
            System.out.println("Received: " + new String(data)); 
        } 
     } 
    

  5. 事件处理器的注册。为了能让事件处理器获得服务线程的事件通知,事件处理器需在触发器中注册。 
     ServerHandler handler = new ServerHandler(); 
     Notifier.addlistener(handler); 
    

实现 NIO 多线程服务器

NIO 多线程服务器主要由主控服务线程、读线程和写线程组成。


(线程模型)
 

  1. 主控服务线程(Server):主控线程将创建读、写线程池,实现监听、接受客户端请求,同时将读、写通道提交由相应的读线程(Reader)和写服务线程 (Writer) ,由读写线程分别完成对客户端数据的读取和对客户端的回应操作。
    public class Server implements Runnable { 
        .... 
        private static int MAX_THREADS = 4; 
        public Server(int port) throws Exception { 
            .... 
            // 创建无阻塞网络套接
            selector = Selector.open(); 
            sschannel = ServerSocketChannel.open(); 
            sschannel.configureBlocking(false); 
            address = new InetSocketAddress(port); 
            ServerSocket ss = sschannel.socket(); 
            ss.bind(address); 
            sschannel.register(selector, SelectionKey.OP_ACCEPT); 
        } 
        public void run() { 
            System.out.println("Server started ..."); 
            System.out.println("Server listening on port: " + port); 
            // 监听
            while (true) { 
                try { 
                    int num = 0; 
                    num = selector.select(); 
                    if (num > 0) { 
                        Set selectedKeys = selector.selectedKeys(); 
                        Iterator it = selectedKeys.iterator(); 
                        while (it.hasNext()) { 
                            SelectionKey key = (SelectionKey) it.next(); 
                            it.remove(); 
                            // 处理 IO 事件
                            if ( (key.readyOps() & SelectionKey.OP_ACCEPT) == 
    							SelectionKey.OP_ACCEPT) { 
                               // Accept the new connection 
                               ServerSocketChannel ssc = 
    							   (ServerSocketChannel) key.channel();
                               notifier.fireOnAccept(); 
                               SocketChannel sc = ssc.accept(); 
                               sc.configureBlocking(false); 
                               // 触发接受连接事件
                               Request request = new Request(sc); 
                               notifier.fireOnAccepted(request); 
                               
                               // 注册读操作 , 以进行下一步的读操作
                               sc.register(selector,  SelectionKey.OP_READ, request);
                           } 
                           else if ( (key.readyOps() & SelectionKey.OP_READ) == 
    						   SelectionKey.OP_READ ) { 
    						   // 提交读服务线程读取客户端数据
                               Reader.processRequest(key);  
                               key.cancel(); 
                           } 
                           else if ( (key.readyOps() & SelectionKey.OP_WRITE) == 
    						   SelectionKey.OP_WRITE ) { 
    						   // 提交写服务线程向客户端发送回应数据
                               Writer.processRequest(key);  
                               key.cancel(); 
                           } 
                        } 
                    } 
                    else { 
                        addRegister();  // 在 Selector 中注册新的写通道
                    } 
                } 
                catch (Exception e) { 
                    notifier.fireOnError("Error occured in Server: " + e.getMessage()); 
                    continue; 
                } 
            } 
        } 
        .... 
    }
    

  2. 读线程(Reader):使用线程池技术,通过多个线程读取客户端数据,以充分利用网络数据传输的时间,提高读取效率。
    public class Reader extends Thread { 
        public void run() { 
            while (true) { 
                try { 
                    SelectionKey key; 
                    synchronized (pool) { 
                        while (pool.isEmpty()) { 
                            pool.wait(); 
                        } 
                        key = (SelectionKey) pool.remove(0); 
                    } 
                    // 读取客户端数据,并触发 onRead 事件
                    read(key);  
                } 
                catch (Exception e) { 
                    continue; 
                } 
            } 
        } 
        .... 
     }

  3. 写线程(Writer):和读操作一样,使用线程池,负责将服务器端的数据发送回客户端。
     public final class Writer extends Thread { 
        public void run() { 
            while (true) { 
                try { 
                    SelectionKey key; 
                    synchronized (pool) { 
                        while (pool.isEmpty()) { 
                            pool.wait(); 
                        } 
                        key = (SelectionKey) pool.remove(0); 
                    } 
                    // 向客户端发送数据,然后关闭连接,并分别触发 onWrite,onClosed 事件
                    write(key); 
                } 
                catch (Exception e) { 
                    continue; 
                } 
            } 
        } 
        .... 
     }

具体应用

NIO 多线程模型的实现告一段落,现在我们可以暂且将 NIO 的各个 API 和烦琐的调用方法抛于脑后,专心于我们的实际应用中。 
我们用一个简单的 TimeServer(时间查询服务器)来看看该模型能带来多么简洁的开发方式。 
在这个 TimeServer 中,将提供两种语言(中文、英文)的时间查询服务。我们将读取客户端的查询命令(GB/EN),并回应相应语言格式的当前时间。在应答客户的请求的同时,服务器将进行日志记录。做为示例,对日志记录,我们只是简单地将客户端的访问时间和 IP 地址输出到服务器的终端上。

  1. 实现时间查询服务的事件处理器(TimeHandler): 
    public class TimeHandler extends EventAdapter { 
        public TimeHandler() { 
        } 
        public void onWrite(Request request, Response response) throws Exception { 
            String command = new String(request.getDataInput()); 
            String time = null; 
            Date date = new Date(); 
            // 判断查询命令
            if (command.equals("GB")) { 
                // 中文格式
                DateFormat cnDate = DateFormat.getDateTimeInstance(DateFormat.FulL, 
                    DateFormat.FulL, Locale.CHINA); 
                time = cnDate.format(date); 
            } 
            else { 
                // 英文格式
                DateFormat enDate = DateFormat.getDateTimeInstance(DateFormat.FulL, 
                    DateFormat.FulL, Locale.US); 
                time = enDate.format(date); 
            } 
            response.send(time.getBytes()); 
        } 
     }


  2. 实现日志记录服务的事件处理器(LogHandler):
    public class LogHandler extends EventAdapter { 
        public LogHandler() { 
        } 
        public void onClosed(Request request) throws Exception { 
            String log = new Date().toString() + " from " + request.getAddress()
    			.toString(); 
            System.out.println(log); 
        } 
        public void onError(String error) { 
            System.out.println("Error: " + error); 
        } 
    }

  3. 启动程序:
    public class Start { 
        public static void main(String[] args) { 
            try { 
                LogHandler loger = new LogHandler(); 
                TimeHandler timer = new TimeHandler(); 
                Notifier notifier = Notifier.getNotifier(); 
                notifier.addlistener(loger); 
                notifier.addlistener(timer); 
                System.out.println("Server starting ..."); 
                Server server = new Server(5100); 
                Thread tServer = new Thread(server); 
                tServer.start(); 
            } 
            catch (Exception e) { 
                System.out.println("Server error: " + e.getMessage()); 
                System.exit(-1); 
            } 
        } 
     }

物流分拣YOLO实战:YOLO26 OBB+YOLOv8多尺度融合,不规则包裹分拣效率提升40%(附训练+部署代码) 在物流分拣的工业场景中,模型的检测精度、推理速度、部署友好性本次基于YOLO26 OBB+YOLOv8多尺度融合打造的物流分拣视觉检测方案,精准解决了工业场景中不规则包裹的旋转检测、多尺度包裹的漏检问题,最终实现分拣效率提升40%,检测准确率提升至95%以上,且模型在边缘设备上的推理帧率稳定35FPS+,完全适配物流分拣的工业落地需求。 阅读详情

相关推荐

什么是Merkle树?用“文件柜”类比理解区块链的核心技术

Merkle树是一种用于区块链的数据结构,像一个高效的“文件柜”,用于存储和验证大量交易数据。比特币通过Merkle树将交易哈希组织成树状结构,层层汇总,最终生成一个唯一的根哈希,存储在区块头中。这种设计大幅减少数据存储和验证成本,支持快速校验交易的完整性和存在性。Merkle树通过密码学保证数据不可篡改,广泛应用于比特币、区块链及其他分布式系统。它的优势在于高效、轻量和安全,尤其适合轻节点验证和数据同步。理解Merkle树就像掌握区块链的“索引秘籍”,是Web3世界的关键技术。

在路上的专栏 1193

JavaNIO——多线程以及IO模型(笔记)

NIO多线程写法与IO模型

weixin_46949627的博客 1718

从服装打版到激光切割:二维异形件排版算法在实际生产中的避坑指南

本文深入探讨二维异形件排版算法在服装、家具等行业的实际应用,对比NFP和重叠移除两种核心策略的优缺点,并提供算法落地的五大实战陷阱与解决方案。通过案例分析和技术要点解析,帮助生产管理者提升材料利用率5%-15%,优化生产效率。

weixin_28717431的博客 418

java多线程的nio_java nio的多线程扩展

前言netty的学习有以下几个难点:netty基于nio进行了较为复杂的封装,而很多童鞋对nio都不是很了解。建议先查看 java NIOnetty中应用了Reactor模式,而Reactor模式本身有多种线程模型可以实现。其实io 模型的多线程扩展方面,不论bio 还是nio 宏观上都类似,这一点可以与 《how tomcat works》笔记 对比着看,tomcat 在演化的过程中,也由单纯的...

weixin_36255893的博客 562

基于Python的信用卡欺诈检测机器学习案例报告

当今时代,在线支付已成为一种高效便捷的支付方式,我们可以突破时间和空间的限制,输入我们的信用卡各项信息就可以完成在线支付。但随之而来的是这种支付方式也具备一定的风险性,我们无法辨别对方是否是恶意套取我们资金的非法分子。当信用卡信息数据泄露导致金钱失窃并最终失去客户忠诚度和公司声誉时,组织、消费者、银行和商家都会面临风险。2017 年,未经授权的信用卡操作达到了惊人的 1670 万受害者。此外,据美国联邦贸易委员会 (FTC) 报告,2017 年信用卡欺诈索赔数量比上一年高出 40%。

weixin_45673389的博客 6697

若依框架整合Flowable:从零构建企业级流程中心

本文详细介绍了如何将若依框架与Flowable工作流引擎整合,构建企业级流程中心。通过环境配置、依赖添加、数据库设置等核心步骤,实现流程定义管理、任务处理服务等关键功能,并结合实际案例展示请假审批流程的实现与动态表单集成。文章还提供了性能优化和生产建议,帮助开发者高效构建稳定可靠的工作流系统。

weixin_28365523的博客 230

【NIO与Netty】Java NIO入门:多线程多Selector模式,零拷贝,同步阻塞、同步非阻塞、同步多路复用、异步非阻塞的区别

尚硅谷+黑马 学习总结:从操作系统的底层逻辑解释同步阻塞、同步非阻塞、同步多路复用、异步非阻塞的区别,分析零拷贝的概念。多线程多Selector模式

知识输出、记录学习 1640

PLC编程入门基础知识

PLC即为可编程逻辑控制器,实质是一种专用于工业控制的计算机,其硬件结构基本上与微型计算机相同。

SANRENYIXING的博客 2万+

java nio 线程_java nio在多线程环境下的恶梦之终结

有人说java nio在多线程环境下编程简直就是个恶梦,其实你如果能把握住java nio API的要领,你就可以将之驾驭.0.一个 channal 对应一个SelectionKey in the same selector.e.g:SelectionKey sk=sc.register(selector, SelectionKey.OP_READ, handler);sk==sc.regist...

weixin_42510060的博客 302

15张图详解三方支付:总架构、5大核心业务处理流程、备付金管理

用户可以将银行卡与零钱账户绑定,建立银行结算账户与支付账户的连接,然后将银行账户资金充值到零钱账户中,或将零钱账号中的余额提现至绑定的银行卡。因此,用户在A支付机构的零钱一般只能支付给A支付机构的商户,如支付宝的零钱不能支付给微信的商户。这五大业务的协同运作,使得第三方支付机构这一庞大的支付服务平台能够为市场提供卓越的支付能力。到了结算时间,网联会向备付金集中存管账户提交结算指令,在第三方支付机构备付金集中存管账户内完成最终的结算,并将结算结果及额度变动情况通知给第三方支付机构,具体流程如图13所示。

银行信息系统应用架构详解 1046

智能汽车嘚啵嘚 --- 智能座舱第七稿:智能座舱的升级OTA

智能汽车嘚啵嘚 --- 智能座舱第七稿:智能座舱的升级OTA

Soly_kun的博客 414

java nio 线程_基于事件的 NIO 多线程服务器

基于事件的 NIO 多线程服务器黄林榕2004 年 4 月 01 日发布JDK1.4 的 NIO 有效解决了原有流式 IO 存在的线程开销的问题,在 NIO 中使用多线程,主要目的已不是为了应对每个客户端请求而分配独立的服务线程,而是通过多线程充分使用用多个 CPU 的处理能力和处理中的等待时间,达到提高服务能力的目的。多线程的引入,容易为本来就略显复杂的 NIO 代码进一步降低可读性和可维护性。...

weixin_32601635的博客 321

使用Simulink进行四足机器人的非线性动力学建模与仿真

四足机器人的运动包含多个自由度(DOF),包括腿部的摆动和支撑阶段的动力学特性。由于存在接触力、摩擦以及不同地形的影响,四足机器人的动力学行为呈现出高度的非线性特征。因此,构建准确的非线性动力学模型对于研究机器人的运动学和动力学特性至关重要。定义代表机器人状态的变量,如位置、速度、角度和角速度。matlab深色版本通过本指南,我们介绍了如何基于Simulink搭建一个四足机器人的非线性动力学模型,并进行了详细分析。

xiaoheshang_123的博客 311

基于事件的NIO多线程服务器

JDK1.4的NIO有效解决了原有流式IO存在的线程开销的问题,在NIO中使用多线程,主要目的已不是为了应对每个客户端请求而分配独立的服务线程,而是通过多线程充分使用用多个CPU的处理能力和处理中的等待时间,达到提高服务能力的目的。 AD: JDK1.4的NIO有效解决了原有流式IO存在的线程开销的问题,在NIO中使用多线程,主要目的已不是为了应对每个客户端请求而分配独立的服务线程...

209

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

【转】基于事件的NIO多线程服务器

黄林榕 (starboy@xdevelop.net), 软件工程师 2004 年 4 月 01 日 JDK1.4提供的无阻塞I/O(NIO)有效解决了多线程服务器存在的线程开销问题,但在使用上略显得复杂一些。许多基于NIO的多线程服务器程序往往直接基于选择器(Selector)的Reactor模式实现。这种简单的事件机制对于较复杂的服务器应用,显然缺乏扩展性和可维护性, 而且缺乏直观清晰的结构层...

weixin_34307464的博客 125

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

基于事件的 NIO 多线程服务器--转载

JDK1.4 的 NIO 有效解决了原有流式 IO 存在的线程开销的问题,在 NIO 中使用多线程,主要目的已不是为了应对每个客户端请求而分配独立的服务线程,而是通过多线程充分使用用多个 CPU 的处理能力和处理中的等待时间,达到提高服务能力的目的。多线程的引入,容易为本来就略显复杂的 NIO 代码进一步降低可读性和可维护性。引入良好的设计模型,将不仅带来高性能、高可靠的代码,也将带来...

101

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

基于事件的NIO多线程服务器(转)

转自:http://www.ibm.com/developerworks/cn/java/l-niosvr/#4JDK1.4提供的无阻塞I/O(NIO)有效解决了多线程服务器存在的线程开销问题,但在使用上略显得复杂一些。许多基于NIO的多线程服务器程序往往直接基于选择器(Selector)的Reactor模式实现。这种简单的事件机制对于较复杂的服务器应用,显然缺乏扩展性和可维护

小毅的书屋 998
上一篇: SpringMvc入门2
下一篇: EveryDay笔记
lvwenwenjava
博客等级 码龄15年 53粉丝 726原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值