NIO 主从Reactor服务

最新推荐文章于 2025-04-01 18:34:59 发布
最新推荐文章于 2025-04-01 18:34:59 发布
阅读量400 收藏 1
点赞数
分类专栏： JAVA 文章标签： Reactor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/andybegin/article/details/123853743
版权

NIO 主从Reactor服务

模型如下：

请添加图片描述

方案说明：

  1. Reactor主线程 MainReactor 对象通过select 监听连接事件, 收到事件后，通过Acceptor 处理连接事件

  2. 当 Acceptor 处理连接事件后，MainReactor 将连接分配给SubReactor

  3. subreactor 将连接加入到连接队列进行监听,并创建handler进行各种事件处理

  4. 当有新事件发生时， subreactor 就会调用对应的handler处理

  5. handler 通过read 读取数据，分发给后面的worker 线程处理

  6. worker 线程池分配独立的worker 线程进行业务处理，并返回结果

  7. handler收到响应的结果后，再通过send 将结果返回给client

  8. Reactor主线程可以对应多个Reactor 子线程, 即MainRecator 可以关联多个SubReactor

方案优缺点说明：

优点:父线程与子线程的数据交互简单职责明确，父线程只需要接收新连接，子线程完成后续的业务处理。

缺点：编程复杂度较高

实现

客户端

package com.company;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.StandardSocketOptions;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.time.LocalDateTime;

/**
 * @author zhe.xiao
 * @date 2022-03-24 9:43
 * @description
 **/
public class ReactorClient {
    public void start() throws IOException, InterruptedException {
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress(12345));
        socketChannel.configureBlocking(false);
        socketChannel.setOption(StandardSocketOptions.TCP_NODELAY, true);

        //不断的自旋、等待连接完成
        while (!socketChannel.finishConnect()) {
            // do
        }

        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //发送数据到服务器
        for (int i = 0; i < 100; i++) {
            String data = "ReactorClient hello zhe " + i + " --- " + LocalDateTime.now();
            System.out.println(data);

            //buffer写模式
            buffer.put(data.getBytes());

            //buffer读模式
            buffer.flip();
            socketChannel.write(buffer);

            //buffer切换写模式
            buffer.clear();
            Thread.sleep(5000);
        }

        //关闭
        socketChannel.shutdownOutput();
        socketChannel.close();
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        new ReactorClient().start();
    }
}

服务端：

package com.company;

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author zhe.xiao
 * @date 2022-03-30 15:47
 * @description
 **/
public class ReactorMasterServer implements Runnable {
    Selector selector;
    ServerSocketChannel serverSocketChannel;

    //当前的selector序号
    AtomicInteger selectorIdx = new AtomicInteger(0);

    //多selector
    private int cpuCores = 8;
    private Selector[] selectorList = new Selector[cpuCores];

    //定义子Reactor及运行子Reactor的线程
    private ReactorSubServer[] reactorSubServerList = new ReactorSubServer[cpuCores];
    private Thread[] reactorSubThreadList = new Thread[cpuCores];

    public ReactorMasterServer(int port) throws IOException {
        selector = Selector.open();

        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(port));
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); //接收accept事件

        System.out.println("ReactorMasterServer 初始化成功");

        //初始化子Reactor
        initReactorSub();
    }

    /**
     * 初始化子Reactor
     *
     * @throws IOException
     */
    private void initReactorSub() throws IOException {
        for (int i = 0; i < cpuCores; i++) {
            //创建选择器
            Selector selector = Selector.open();
            selectorList[i] = selector;

            //创建子Reactor
            ReactorSubServer reactorSubServer = new ReactorSubServer(selector, serverSocketChannel, i);
            reactorSubServerList[i] = reactorSubServer;

            //启动线程
            Thread thread = new Thread(reactorSubServer);
            reactorSubThreadList[i] = thread;
        }
    }


    @Override
    public void run() {
        //启动子Reactor线程
        for (Thread thread : reactorSubThreadList) {
            thread.start();
        }

        try {
            while (!Thread.interrupted()) {
                selector.select();

                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> keyIterator = selectionKeys.iterator();

                while (keyIterator.hasNext()) {
                    SelectionKey selectionKey = keyIterator.next();

                    if (selectionKey.isAcceptable()) {
                        new Acceptor(serverSocketChannel).run();
                    }

                    keyIterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 处理线程接收
     */
    class Acceptor implements Runnable {
        final ServerSocketChannel serverSocketChannel;

        Acceptor(ServerSocketChannel serverSocketChannel) throws IOException {
            this.serverSocketChannel = serverSocketChannel;
        }

        @Override
        public void run() {
            try {
                SocketChannel socketChannel = serverSocketChannel.accept();
                System.out.println(socketChannel.socket().getRemoteSocketAddress().toString() + " is connected.");

                if (socketChannel != null) {
                    socketChannel.configureBlocking(false);

                    //暂停子Reactor
                    reactorSubServerList[selectorIdx.get()].setSuspend(true);
                    // 使一個阻塞住的selector操作立即返回,不然的话会一直被suspend
                    selectorList[selectorIdx.get()].wakeup();

                    //针对某个selector注册事件
                    System.out.println("注册 Selector到索引：" + selectorIdx.get());
                    socketChannel.register(selectorList[selectorIdx.get()], SelectionKey.OP_READ);

                    //启动子Reactor
                    reactorSubServerList[selectorIdx.get()].setSuspend(false);
                    // 使一個阻塞住的selector操作立即返回，不然的话会一直被suspend
                    selectorList[selectorIdx.get()].wakeup();


                    //重置索引
                    selectorIdx.incrementAndGet();
                    if (selectorIdx.get() == selectorList.length) {
                        selectorIdx.set(0);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    public static void main(String[] args) throws IOException {
        Thread thread = new Thread(new ReactorMasterServer(12345));
        thread.start();
    }
}

/**
 * 核心的Reactor服务
 */
class ReactorSubServer implements Runnable {
    final Selector selector;
    final ServerSocketChannel serverSocketChannel;
    private int selectorIdx;

    //暂停线程
    private boolean suspend = false;

    public ReactorSubServer(Selector selector, ServerSocketChannel serverSocketChannel, int selectorIdx) {
        this.selector = selector;
        this.serverSocketChannel = serverSocketChannel;
        this.selectorIdx = selectorIdx;

        System.out.println("启动子Reactor ReactorSubServer 线程:" + selectorIdx);
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
//                System.out.println("启动子Reactor ReactorSubServer 线程 " + selectorIdx + " 暂停中");

                //判断是否暂停
                while (!suspend) {
                    selector.select();
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();
                    Iterator<SelectionKey> keyIterator = selectionKeys.iterator();

                    while (keyIterator.hasNext()) {
                        System.out.println("启动子Reactor ReactorSubServer 线程 " + selectorIdx + " 运行中");

                        SelectionKey selectionKey = keyIterator.next();

                        if (selectionKey.isReadable()) {
                            new ReactorMasterHandler(selectionKey).run();
                        }

                        keyIterator.remove();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void setSuspend(boolean suspend) {
        this.suspend = suspend;
    }
}


/**
 * 线程池处理器
 */
class ReactorMasterHandler implements Runnable {
    SelectionKey selectionKey;
    SocketChannel socketChannel;
    private static final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 100, 10L, TimeUnit.SECONDS, new LinkedBlockingDeque<>());


    public ReactorMasterHandler(SelectionKey selectionKey) {
        this.selectionKey = selectionKey;
    }

    @Override
    public void run() {
        try {
            if (selectionKey.isReadable()) {
                readOperate();
            } else {
                //写操作
            }
        } catch (Exception e) {
            closeChannel();
        }
    }

    /**
     * 执行读
     *
     * @throws IOException
     */
    private synchronized void readOperate() throws IOException {
        socketChannel = (SocketChannel) selectionKey.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int len = 0;
        while ((len = socketChannel.read(buffer)) > 0) {
            String str = new String(buffer.array(), 0, len);
            threadPoolExecutor.execute(new WorkThread(str));
        }
    }

    /**
     * 关闭
     */
    private void closeChannel() {
        selectionKey.cancel();
        try {
            socketChannel.close();
        } catch (IOException e) {
            System.out.println("close error");
        }
        System.out.println("关闭连接");
    }

    /**
     * 业务逻辑交给工作线程处理
     */
    static class WorkThread implements Runnable {
        String input;

        public WorkThread(String input) {
            this.input = input;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " input : " + input);
        }
    }

}
JavaIO_第五篇：基于NIO的Reactor三种模式
毛毛的专栏
08-14 1245
文章目录一、前言二、bytebuffer的基本使用(非重要,仅仅bytebuffer的语法,面试无用)2.1 Demo1_Random_Print2.1.1 bytebuffer三种变量：position limit capacity2.1.2 Demo1_Random_Print2.2 Demo2_Read_Print2.3 Demo3_bytes_Write2.4 Demo4_Read_Write2.5 Demo52.6 Demo62.7 Demo72.8 Demo8_Read_Write_Direc
[动手实现] IO模式:NIO:主从Reactor
weisman2的博客
06-14 284
NIO基础 NIO（Non-blocking IO） 是一种同步非阻塞支持面向缓冲的，基于通道的I/O，也是IO多路复用的基础，主要是解决高并发 或者 处理海量连接，IO处理问题 IO模式 所有的IO模式都分为两个阶段， 一是等待就绪（准备数据）也就是从网卡copy到内核缓存区（从内核缓存区copy到网卡）， 二是真正的操作（读，写） 也就是从内核缓存区copy到用户地址空间； IO模式 等待就绪阶段 是否阻塞 读写、拷贝阶段 是否阻塞 BIO （Blocking IO） 是 是 NIO
Java之NIO、主从Reactor
m0_38140207的博客
07-26 369
1. NIO 基本介绍 ① Java NIO 全称java non-blocking IO，是同步非阻塞的 ② NIO有三大核心部分: Channel(通道),Buffer(缓冲区), Selector(选择器) ③ NIO是面向缓冲区编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络 ④ Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都
13.主从 Reactor 模式的实现
最新发布
记录计算机学习路程
04-01 792
因为loop_可能在其他地方访问，而IO线程函数退出时，线程已经不能继续运行，代表IO线程EventLoop的loop_也就没有了存在意义。如果不清空，析构函数可能会导致重复调用loop_->quit()，让IO线程loop循环重复退出。
13.主从Reactor模型
m0_57408211的博客
12-03 1417
在第10节，我们实现了单Reactor模式，这是已经比较完善的了。但是也还可能会有问题。 单Reactor模式中，也就是单个EventLoop,它需要管理建立连接的，也需要管理与客户端进行通信的，当IO压力比较大的时候，响应就可能不会这么及时。 我们可以使用多个Reactor,一个主Reactor就负责与客户端建立连接的，其他的从Reactor就负责与客户端通信的。这分工明确,IO的压力也会分担开来，更能适应高性能的需求。
主从Reactor服务器
tiz
05-14 689
此时该连接有新的通信，（通过调用回调的方式，任意事件回调）那么我们就针对该连接的智能指针再创建一个智能指针，使得智能指针的计数器+1，并将对断开连接的操作放到时间轮的新位置，这样，当 时间轮走到旧的位置时，虽然仍然会释放连接，智能指针的计数-1，但由于计数未到0，不执行类的析构函数，达到刷新任务的目的，也就是我们说的非活跃连接销毁。调用对应的处理函数后，再将函数处理结果接入响应报文的正文之中，就可以按照响应报文的格式组织发送了，发送完毕后，重置该连接的上下文，并根据其长短连接属性决定是否断开连接。
Reactor 主从线程模型
Flying_Fish_roe的博客
11-14 722
主从 Reactor 模型是一种改进的多线程 Reactor 模型，它将事件处理过程分为两级：主 Reactor 负责处理连接请求，从 Reactor 负责处理已连接客户端的 I/O 操作。通过将不同类型的事件分配给不同的线程组，主从 Reactor 模型进一步提高了系统的并发处理能力和资源利用效率。
Netty之主从Reactor多线程模型
wangpf2011的博客
07-19 4919
Reactor模式用于解决高性能IO问题，特别适合处理海量的I/O事件，它是当前大多数IO组件所采用的IO模式。Netty网络框架就是基于Reactor模式进行设计和开发的，当请求抵达后，服务处理程序使用多路分配策略，同步地派发这些请求至相关的请求处理程序。 Netty可以通过配置不同参数实现不同Reactor线程模型，在Netty的官方demo中，推荐使用主从Reactor多线程模型，所以这里...
reactor:NIO 编程模型 - Reactor，各版本实现
05-29
MultiReactor: 主从 Reactor MultithreadHandler: 线程池处理器 Reactor: 接收连接，I/O 读写 Reactor 模型的说明： Getting started 编译 javac -encoding utf-8 *.java 运行 java Reactor java MultiReactor 测试 ...
Java NIO与Reactor模式：构建高性能服务器应用的终极指南
[Java NIO与Reactor模式：构建高性能服务器应用的终极指南](https://img-blog.csdnimg.cn/5093feab42874bdeb39ac8af1dd1c38a.png) # 1. Java NIO基础与核心概念 Java NIO（New IO，Non-Blocking IO）是在Java 1.4中...
【netty学习】之主从Reactor
lc_23333的博客
09-29 473
【netty学习】之主从Reactor
主从reactor模式
xupeng1644的博客
05-12 1892
muduo中，类EventLoopThreadPool的构造函数将成员numThreads_设置为0，表示默认不开启主从reactor模式。 通过在调用void TcpServer::start()之前，调用EventLoopThreadPool::setThreadNum()。即可开启主从reactor模式。 类TcpServer的结构如下： class TcpServer : noncopyable { public: ... private: EventLoop* loop_; // the a
reactor模式：主从式reactor
mweibiao的博客
03-27 3694
前面两篇文章提到 reactor模式：单线程的reactor模式 reactor模式：多线程的reactor模式 NIO的server模式只有5个阶段，但是，NIO的selectionkey里确实有个accept事件，所以，为了区别，衍生出了主reactor和从reactor 并且，从reactor可以根据服务器的负荷，新增多个从reactor进行请求处理 服务器架构如下图 这个就...
主从reactor 多线程模型
地推
10-24 335
相比多线程reactor模型，主从reactor多线程模型拥有了一个独立处理 SocketChannel 连接的线程池，当客户端从Acceptor建立连接之后，便将该连接绑定到subreactor 线程池中的某个线程中，然后由该线程绑定客户端感兴趣的I/O事件（READ/WRITE），监听客户端连接请求，最后处理。 mainReactor : 监听 ServerSocketChannel 、建立与 SocketChannel 的连接、将完成建立连接之后的Socket 交给subReactor subRe
主从Reactor模式 任务池提高请求处理效率分析
gma999的博客
08-07 697
主从Reactor中任务池的作用分析
主从Reactor多线程原理学习
u012396459的专栏
04-05 917
主从Reactor多线程原理
从java的角度看reactor主从线程模型
爱笑的k11的博客
01-21 550
1写在前面 常用的 Reactor 线程模型有三种， Reactor 单线程模型, Reactor 多线程模型, 主从 Reactor 多线程模 型。本文主要介绍主从Reactor多线程模型，并写一个小的demo。 主从Reactor多线程模型 服务端用于接收客户端连接的不再是个 1 个单独的 NIO 线程，而是一个独立的 NIO 线程池。 Acceptor 接收到客户端 TCP 连接请求处理完成...
Java网络编程- IO多路复用(多Reactor)(主从式Reactor)
怪盗基德
04-28 3534
1. 介绍 本篇文章将IO多路复用(多线程)中的单Reactor+多线程网络模型做了改进， 把Reactor拆成两个角色Main Reactor及Sub Reactor，以提升效能与资源利用率​​。 Main Reactor：负责监听外部的连线请求，并派发给Acceptor处理。故Main Reactor中的selector只有注册OP_ACCEPT事件，也只能监听O
找工作小项目：day12-主从Reactor模式
ablelay的博客
06-03 998
day12完成了多Reactor多线程，最主要的差别是在分配处理的方式上，即将newConnection绑定到main-Reactor上并在newConnection中进行分配，分配方案使用的是哈希表分配，这个调度方案使得每个线程负载相同，然而，不同的业务传输的数据极有可能不一样，也可能受到网络条件等因素的影响，极有可能会造成一些subReactor线程十分繁忙，而另一些subReactor线程空空如也，这只需要在事件中加入相应的标志，并根据标志利用线程池进行任务优先级分配，下面是一段类似于伪代码的改写。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值