reactor模式：多线程的reactor模式

最新推荐文章于 2024-10-05 16:23:08 发布
最新推荐文章于 2024-10-05 16:23:08 发布
阅读量8k 收藏 10
点赞数 1
分类专栏： java nio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mweibiao/article/details/79713423
版权

上文说到单线程的reactor模式 reactor模式：单线程的reactor模式

单线程的reactor模式并没有解决IO和CPU处理速度不匹配问题，所以多线程的reactor模式引入线程池的概念，把耗时的IO操作交由线程池处理，处理完了之后再同步到selectionkey中，服务器架构图如下

 

 

上文（reactor模式：单线程的reactor模式）提到，以read和send阶段IO最为频繁，所以多线程的reactor版本里，把这2个阶段单独拎出来。

下面看看代码实现

 

    // Reactor線程 （该类与单线程的处理基本无变动） 
    package server;  
      
    import java.io.IOException;  
    import java.net.InetSocketAddress;  
    import java.nio.channels.SelectionKey;  
    import java.nio.channels.Selector;  
    import java.nio.channels.ServerSocketChannel;  
    import java.util.Iterator;  
    import java.util.Set;  
      
    public class TCPReactor implements Runnable {  
      
        private final ServerSocketChannel ssc;  
        private final Selector selector;  
      
        public TCPReactor(int port) throws IOException {  
            selector = Selector.open();  
            ssc = ServerSocketChannel.open();  
            InetSocketAddress addr = new InetSocketAddress(port);  
            ssc.socket().bind(addr); // 在ServerSocketChannel綁定監聽端口  
            ssc.configureBlocking(false); // 設置ServerSocketChannel為非阻塞  
            SelectionKey sk = ssc.register(selector, SelectionKey.OP_ACCEPT); // ServerSocketChannel向selector註冊一個OP_ACCEPT事件，然後返回該通道的key  
            sk.attach(new Acceptor(selector, ssc)); // 給定key一個附加的Acceptor對象  
        }  
      
        @Override  
        public void run() {  
            while (!Thread.interrupted()) { // 在線程被中斷前持續運行  
                System.out.println("Waiting for new event on port: " + ssc.socket().getLocalPort() + "...");  
                try {  
                    if (selector.select() == 0) // 若沒有事件就緒則不往下執行  
                        continue;  
                } catch (IOException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                Set<SelectionKey> selectedKeys = selector.selectedKeys(); // 取得所有已就緒事件的key集合  
                Iterator<SelectionKey> it = selectedKeys.iterator();  
                while (it.hasNext()) {  
                    dispatch((SelectionKey) (it.next())); // 根據事件的key進行調度  
                    it.remove();  
                }  
            }  
        }  
      
        /* 
         * name: dispatch(SelectionKey key) 
         * description: 調度方法，根據事件綁定的對象開新線程 
         */  
        private void dispatch(SelectionKey key) {  
            Runnable r = (Runnable) (key.attachment()); // 根據事件之key綁定的對象開新線程  
            if (r != null)  
                r.run();  
        }  
      
    }

 

    // 接受連線請求線程  
    package server;  
      
    import java.io.IOException;  
    import java.nio.channels.SelectionKey;  
    import java.nio.channels.Selector;  
    import java.nio.channels.ServerSocketChannel;  
    import java.nio.channels.SocketChannel;  
      
    public class Acceptor implements Runnable {  
      
        private final ServerSocketChannel ssc;  
        private final Selector selector;  
          
        public Acceptor(Selector selector, ServerSocketChannel ssc) {  
            this.ssc=ssc;  
            this.selector=selector;  
        }  
          
        @Override  
        public void run() {  
            try {  
                SocketChannel sc= ssc.accept(); // 接受client連線請求  
                System.out.println(sc.socket().getRemoteSocketAddress().toString() + " is connected.");  
                  
                if(sc!=null) {  
                    sc.configureBlocking(false); // 設置為非阻塞  
                    SelectionKey sk = sc.register(selector, SelectionKey.OP_READ); // SocketChannel向selector註冊一個OP_READ事件，然後返回該通道的key  
                    selector.wakeup(); // 使一個阻塞住的selector操作立即返回  
                    sk.attach(new TCPHandler(sk, sc)); // 給定key一個附加的TCPHandler對象  
                }  
                  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
      
          
    }

 

    // Handler線程  
    package server;  
      
    import java.io.IOException;  
    import java.nio.channels.SelectionKey;  
    import java.nio.channels.SocketChannel;  
    import java.util.concurrent.LinkedBlockingQueue;  
    import java.util.concurrent.ThreadPoolExecutor;  
    import java.util.concurrent.TimeUnit;  
      
    public class TCPHandler implements Runnable {  
      
        private final SelectionKey sk;  
        private final SocketChannel sc;  
        private static final int THREAD_COUNTING = 10;  
        private static ThreadPoolExecutor pool = new ThreadPoolExecutor(  
                THREAD_COUNTING, THREAD_COUNTING, 10, TimeUnit.SECONDS,  
                new LinkedBlockingQueue<Runnable>()); // 線程池  
      
        HandlerState state; // 以狀態模式實現Handler  
      
        public TCPHandler(SelectionKey sk, SocketChannel sc) {  
            this.sk = sk;  
            this.sc = sc;  
            state = new ReadState(); // 初始狀態設定為READING  
            pool.setMaximumPoolSize(32); // 設置線程池最大線程數  
        }  
      
        @Override  
        public void run() {  
            try {  
                state.handle(this, sk, sc, pool);  
                  
            } catch (IOException e) {  
                System.out.println("[Warning!] A client has been closed.");  
                closeChannel();  
            }  
        }  
          
        public void closeChannel() {  
            try {  
                sk.cancel();  
                sc.close();  
            } catch (IOException e1) {  
                e1.printStackTrace();  
            }  
        }  
      
        public void setState(HandlerState state) {  
            this.state = state;  
        }  
    }

 

    package server;  
      
    import java.io.IOException;  
    import java.nio.channels.SelectionKey;  
    import java.nio.channels.SocketChannel;  
    import java.util.concurrent.ThreadPoolExecutor;  
      
    public interface HandlerState {  
      
        public void changeState(TCPHandler h);  
      
        public void handle(TCPHandler h, SelectionKey sk, SocketChannel sc,  
                ThreadPoolExecutor pool) throws IOException ;  
    }

 

    package server;  
      
    import java.io.IOException;  
    import java.nio.ByteBuffer;  
    import java.nio.channels.SelectionKey;  
    import java.nio.channels.SocketChannel;  
    import java.util.concurrent.ThreadPoolExecutor;  
      
    public class ReadState implements HandlerState{  
      
        private SelectionKey sk;  
          
        public ReadState() {  
        }  
          
        @Override  
        public void changeState(TCPHandler h) {  
            // TODO Auto-generated method stub  
            h.setState(new WorkState());  
        }  
      
        @Override  
        public void handle(TCPHandler h, SelectionKey sk, SocketChannel sc,  
                ThreadPoolExecutor pool) throws IOException { // read()  
            this.sk = sk;  
            // non-blocking下不可用Readers，因為Readers不支援non-blocking  
            byte[] arr = new byte[1024];  
            ByteBuffer buf = ByteBuffer.wrap(arr);  
              
            int numBytes = sc.read(buf); // 讀取字符串  
            if(numBytes == -1)  
            {  
                System.out.println("[Warning!] A client has been closed.");  
                h.closeChannel();  
                return;  
            }  
            String str = new String(arr); // 將讀取到的byte內容轉為字符串型態  
            if ((str != null) && !str.equals(" ")) {  
                h.setState(new WorkState()); // 改變狀態(READING->WORKING)  
                pool.execute(new WorkerThread(h, str)); // do process in worker thread  
                System.out.println(sc.socket().getRemoteSocketAddress().toString()  
                        + " > " + str);  
            }  
              
        }  
          
        /* 
         * 執行邏輯處理之函數 
         */  
        synchronized void process(TCPHandler h, String str) {  
            // do process(decode, logically process, encode)..  
            // ..  
            h.setState(new WriteState()); // 改變狀態(WORKING->SENDING)  
            this.sk.interestOps(SelectionKey.OP_WRITE); // 通過key改變通道註冊的事件  
            this.sk.selector().wakeup(); // 使一個阻塞住的selector操作立即返回  
        }  
      
        /* 
         * 工作者線程 
         */  
        class WorkerThread implements Runnable {  
      
            TCPHandler h;  
            String str;  
      
            public WorkerThread(TCPHandler h, String str) {  
                this.h = h;  
                this.str=str;  
            }  
      
            @Override  
            public void run() {  
                process(h, str);  
            }  
      
        }  
    }

 

    package server;  
      
    import java.io.IOException;  
    import java.nio.channels.SelectionKey;  
    import java.nio.channels.SocketChannel;  
    import java.util.concurrent.ThreadPoolExecutor;  
      
    public class WorkState implements HandlerState {  
      
        public WorkState() {  
        }  
          
        @Override  
        public void changeState(TCPHandler h) {  
            // TODO Auto-generated method stub  
            h.setState(new WriteState());  
        }  
      
        @Override  
        public void handle(TCPHandler h, SelectionKey sk, SocketChannel sc,  
                ThreadPoolExecutor pool) throws IOException {  
            // TODO Auto-generated method stub  
              
        }  
      
    }

 

    package server;  
      
    import java.io.IOException;  
    import java.nio.ByteBuffer;  
    import java.nio.channels.SelectionKey;  
    import java.nio.channels.SocketChannel;  
    import java.util.concurrent.ThreadPoolExecutor;  
      
    public class WriteState implements HandlerState{  
      
        public WriteState() {  
        }  
          
        @Override  
        public void changeState(TCPHandler h) {  
            // TODO Auto-generated method stub  
            h.setState(new ReadState());  
        }  
      
        @Override  
        public void handle(TCPHandler h, SelectionKey sk, SocketChannel sc,  
                ThreadPoolExecutor pool) throws IOException { // send()  
            // get message from message queue  
              
            String str = "Your message has sent to "  
                    + sc.socket().getLocalSocketAddress().toString() + "\r\n";  
            ByteBuffer buf = ByteBuffer.wrap(str.getBytes()); // wrap自動把buf的position設為0，所以不需要再flip()  
      
            while (buf.hasRemaining()) {  
                sc.write(buf); // 回傳給client回應字符串，發送buf的position位置 到limit位置為止之間的內容  
            }  
              
            h.setState(new ReadState()); // 改變狀態(SENDING->READING)  
            sk.interestOps(SelectionKey.OP_READ); // 通過key改變通道註冊的事件  
            sk.selector().wakeup(); // 使一個阻塞住的selector操作立即返回  
        }  
    }

 

    package server;  
      
    import java.io.IOException;  
      
    public class Main {  
      
          
        public static void main(String[] args) {  
            // TODO Auto-generated method stub  
            try {  
                TCPReactor reactor = new TCPReactor(1333);  
                reactor.run();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
      
    }

 

 

 

 

 

总的来说，多线程版本的reactor是为了解决单线程reactor版本的IO和CPU处理速度不匹配问题，从而达到高效处理的目的

 

参考文章：

https://blog.csdn.net/yehjordan/article/details/51017025

无名草110
关注
专栏目录
网络编程模式Reactor详解
qq_39751437的博客
04-11 1373
前言 在web服务器开发中，有2种常见的架构，基于线程的架构和事件驱动的架构。初期使用一个连接用一个线程来处理，这样显然对于高并发连接而言会使得线程创建开销很大，而改进方法使用多进程来处理每个请求，这样单个请求出问题不会影响到其它请求，但进程切换很慢且内存消耗很大。为了优化线程数量以获得最佳的整体性能，同时为了避免线程创建/销毁的开销，通常在实际应用中**，会在一个数量有限的阻塞队列上使用一个单独...
reactor多线程模型_图解Reactor模型
weixin_39615991的博客
01-11 956
在BIO线程模型中，为了解决同步阻塞的问题，采用了多线程的方式处理并发，即经典的connection per thread，每一个连接用一个线程处理。虽然在单个线程内仍然是阻塞的，但在整体上看是可以同时处理多个连接请求的，原理图如下：但这种方式的缺点在于资源要求太高，系统中创建线程是需要比较高的系统资源的，如果连接数太多，系统无法承受，而且，线程的反复创建和销毁也需要代价...
Reactor 模式
最新发布
m0_69323023的博客
10-05 1354
Reactor模式
wpf 多线程处理同步数据_多线程的Reactor反应器模式
weixin_39550937的博客
11-24 321
既然Reactor反应器和Handler处理器，挤在-一个线程会造成非常严重的性能缺陷。那么，可以使用多线程，对基础的反应器模式进行改造和演进。多线程池Reactor反应器演进多线程池Reactor反应器的演进，分为两个方面:(1)首先是升级Handler处理器。既要使用多线程，又要尽可能的高效率，则可以考虑使用线程池。(2)其次是升级Reactor反应器。可以考虑引入多个Selector选择器，...
多线程Reactor分析,从性能,客户接入量方向
小杰312的博客
04-05 3683
多线程Reactor分析,从性能,客户接入量方向
基于Reactor 模式的多线程现代化C++11网络库.zip
03-17
【项目资源】： 包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源、音视频、网站开发等各种技术项目的源码。 ... 【项目质量】： 所有源码都经过严格测试，...
net:基于Reactor 模式的多线程现代化C++11网络库
05-17
个人毕设作品。...非阻塞纯异步多线程TCP服务器/客户端 单核环境支持 线程安全 线程安全的退出，重启 客户端断线自动重连 服务端可同时监听多个ip/port ipv6支持 例子 Tcp Echo Server #include"TcpSe
ACE作者解读：Reactor模式：事件驱动服务的并发处理
Reactor模式是一种面向对象的行为设计模式，主要应用于处理并发的服务请求，这些请求可能来自一个或多个客户端。...在实际开发中，尤其是在多线程或者异步编程场景下，Reactor模式是一种非常实用的设计策略。
Reactor模式：事件驱动的分布式日志服务器设计
这解决了多线程中的并发控制问题，避免了上下文切换、同步和数据移动导致的性能损失。 4. **事件处理器（Event Handler）**：每个服务对应一个事件处理器，它们负责处理客户端请求，如记录日志。这与多线程模型相比...
reactor多线程模型_理解Reactor模型
weixin_39663729的博客
02-01 265
1. 基本概念1.1 背景为了处理Web请求，有以下两种架构处理方式1.1.1 基于线程的架构也就是一个连接一个线程，即BIO的方式优点：可以隔离每个请求，请求之间互不影响缺点：严重依赖于线程，虽然线程相比于进程轻量级，但还是很占用资源线程的创建和销毁成本很高(可以通过线程池和有界阻塞队列优化)线程本身占用较大的内存线程的切换成本是很高的容易造成锯齿状的系统负载无法解决C10K问题适用场...
多线程处理的几种模式—Proactor和Reactor
xiaomin1991222的专栏
09-17 348
Proactor和Reactor都是并发编程中的设计模式。他们都是用于派发/分离IO操作事件的。所谓的IO事件也就是诸如read/write的IO操作。"派发/分离"就是将单独的IO事件通知到上层模块。两个模式不同的地方在于，Proactor用于异步IO，而Reactor用于同步IO。     Two patterns that involve event demultiplexors ar...
多线程Reactor模式
qq_36284689的博客
12-02 1436
文章目录1.1 主服务器2.1 IO请求handler+线程池3.1 客户端 多线程Reactor模式旨在分配多个reactor每一个reactor独立拥有一个selector，在网络通信中大体设计为负责连接的主Reactor,其中在主Reactor的run函数中若selector检测到了连接事件的发生则dispatch该事件。 让负责管理连接的Handler处理连接，其中在这个负责连接的Handler处理器中创建子Handler用以处理IO请求。这样一来连接请求与IO请求分开执行提高通道的并发量。同时多
Reactor线程模型
qq_44807343的博客
04-17 840
Reactor 模式 针对传统阻塞 I/O 服务模型的 2 个缺点，比较常见的有如下解决方案： 基于 I/O 复用模型：多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象上等待，无需阻塞等待所有连接。当某条连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理； 基于线程池复用线程资源：不必再为每个连接创建线程，将连接完成后的业务处理任务分配给线程进行处理，一个线程可以处理多个连接的业务。 I/O 复用结合线程池，这就是 Reactor 模式基本设计思想，如下图： R
Reactor模式-多线程
qq_30055391的博客
12-22 685
1.流程图 可以看出 相比单线程的reactor模式来说，多线程的模式使用了线程池来管理多个线程来处理各个socket连接的读写请求，而比较简单的连接请求还是交给一个主线程来处理。只有发生读写时间的时候才会分发给各个线程来处理读写逻辑。 2.什么情况下socket是可读和可写的 引用的是https://blog.csdn.net/nosix/article/details/77484562这篇文...
Reactor模型-多线程程版
weixin_30730053的博客
12-19 115
1.概述 在Reactor单线程版本的设计中，I/O任务乃至业务逻辑都由Reactor线程来完成，这无疑增加了Reactor线程的负担，高负载情况下必然会出现性能瓶颈。此外，对于多处理器的服务器来说，单个Reactor线程也发挥不了多CPU的最大功效。下面我们对之前单线程版的Reactor进行改进。 改进方向 接受客户端连接请求的不在是单个线程-Acceptor，而是一个NIO线...
【Netty】主从反应器 ( Reactor ) 多线程模型
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
06-02 2231
一、 主从 反应器 ( Reactor ) 多线程 模式 、 二、 主从 反应器 ( Reactor ) 多线程 工作流程 、 三、 主从 反应器 ( Reactor ) 多线程 优缺点分析 、 四、 单个主 Reactor 多个从 Reactor 多线程模型元素 、 五、 单个主 Reactor 多个从 Reactor 多线程模型工作流程 、 六、 多个主 Reactor 多个从 Reactor 多线程模型 、
Java 高并发编程——Reactor模式（多线程）
geminigoth的博客
01-30 1656
为了提升效率，可以让SubReactor的数量和选择器的数量一致，避免多个线程负责一个选择器，导致需要进行线程同步，引起效率低下。2、设计一个新的子反应器（SubReactor）类，子反应器负责查询一个选择器。3、开发多个处理线程，一个处理器负责执行一个子反应器。的基础上完成多线程反应器的升级。1、引入多个选择器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值