NIO Reactor模型(含代码)

已于 2023-03-30 09:45:37 修改
阅读量1.6k 收藏 5
点赞数
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： nio Reactor模型 网络编程 java
于 2023-03-29 21:03:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/longqicsdn/article/details/129843568
文章详细介绍了NIO中的Reactor模型，包括单Reactor单线程和单Reactor多线程两种实现方式。在单线程模型中，整个服务器的执行流程都在同一个线程中顺序进行，而多线程模型则引入线程池来提高处理速度。代码示例展示了如何使用Selector注册事件并分发到相应的处理器进行处理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

概览

        我们知道NIO就是调用系统内核的的select/poll/epoll方法来实现，这些系统内核方法会扫描或监控IO，每次将所有的IO的状态返回给NIO线程。让NIO线程可以选择处理读取可读状态的IO流，也可以选择继续监控轮询监控IO的其它状态。

        reactor模型也叫做Dispatcher模型，即分发模型，NIO中分发线程和处理线程策略不同而衍生出了四种网络编程模型：单Reactor单线程、单Reactor多线程、多Reactor多线程。

单Reactor单线程

       这里无非就是整个NIO Server里都是单线程顺序执行，Reactor调用select()方法IO状态为ACCEPT就派发给Acceptor处理，IO状态为OP_READ或OP_WRITE则派发给handler进行处理。

上图Reactor获取到IO状态后，依旧是单线程按顺序进行处理。具体代码如下：

package com.longqi.boottest.io;

import java.net.InetSocketAddress;
import java.net.Socket;
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.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author LongQi
 * @projectName boot-integration
 * @description: TODO
 * @date 2023/3/29 20:06
 */

public class SingleReactorSingleThread {

    public static void main(String[] args) {
        int port = 8080;
        Server server = new Server(port);
        server.start();
        sendMessage(port);
    }

    static class Server{
        private int port;
        public Server(int port){
            this.port=port;
        }
        public void start(){
            try {
                ServerSocketChannel server = ServerSocketChannel.open();
                server.configureBlocking(false);
                server.socket().bind(new InetSocketAddress(port));
                Selector selector = Selector.open();
                // 设置select监听的事件
                server.register(selector, SelectionKey.OP_ACCEPT);
                new Thread(new Reactor(selector)).start();
            }catch (Exception e){
                System.out.println("服务器启动失败:"+e.getMessage());
                e.printStackTrace();
            }
        }
    }

    static class Reactor implements Runnable{
        private Selector selector;
        private Dispatch dispatch = new Dispatch();
        public Reactor(Selector selector){
            this.selector=selector;
        }

        @Override
        public void run() {
            try{
                while (true){
                    int n = selector.select();
                    if(n > 0){
                        Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                        while (iterator.hasNext()){
                            SelectionKey key = iterator.next();
                            dispatch.dispatch(selector,key);
                            iterator.remove();
                        }
                    }
                }
            }catch (Exception e){
                System.out.println("服务器运行异常:"+e.getMessage());
                e.printStackTrace();
            }
        }
    }

    static class Dispatch{
        private ReadHandler handler = new ReadHandler();
        private Acceptor acceptor = new Acceptor();

        public void dispatch(Selector selector,SelectionKey key){
            if(key.isAcceptable()){
                acceptor.hand(selector,key);
            }
            if(key.isReadable()){
                handler.hand(key);
            }
        }
    }

    static class Acceptor{
        public void hand(Selector selector,SelectionKey key){
            try{
                ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                SocketChannel clientChannel = serverChannel.accept();
                clientChannel.configureBlocking(false);
                clientChannel.register(selector,SelectionKey.OP_READ);
            }catch (Exception e){
                System.out.println("处理请求异常:"+e.getMessage());
                e.printStackTrace();
            }
        }
    }

    static class ReadHandler{
        public void hand(SelectionKey key){
            try{
                SocketChannel channel = (SocketChannel) key.channel();
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                while (channel.read(buffer)!=-1){
                    //复位，转化为读模式
                    buffer.flip();
                    while (buffer.hasRemaining()){
                        System.out.println("收到客户端"+channel.socket().getPort()+"的信息："+ StandardCharsets.UTF_8.decode(buffer).toString());
                    }
                    //清空缓存区，转化为写模式
                    buffer.clear();
                }
            }catch (Exception e){
                System.out.println("处理请求异常:"+e.getMessage());
                e.printStackTrace();
            }
        }
    }

    public static void sendMessage(int port) {
        try{
            Thread.sleep(2000);
            ThreadPoolExecutor clientPool = new ThreadPoolExecutor(200,300,60, TimeUnit.SECONDS,new LinkedBlockingQueue<>(800));
            for(int i=0;i<300;i++){
                clientPool.submit(new Runnable() {
                    @Override
                    public void run() {
                        try{
                            Socket client = new Socket();
                            client.connect(new InetSocketAddress("127.0.0.1",port));
                            client.getOutputStream().write(("hello world,send time:"+System.nanoTime()).getBytes());
                            // 注意TCP粘包，这里不调用close，服务器是收不到消息的
                            client.close();
                        }catch (Exception e){
                            System.out.println("客户端发送信息失败");
                        }
                    }
                });
            }
        }catch (Exception e){
            System.out.println("客户端发送信息失败");
        }
    }
}

 单Reactor多线程

       这里NIO Server里都是单个Reactor调用select()方法，然后派发给handler时使用线程池进行处理。大大提升处理速度。

上图Reactor获取到IO状态后，可读可写的channel由线程池开线程进行处理。具体代码如下：

package com.longqi.boottest.io;

import java.net.InetSocketAddress;
import java.net.Socket;
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.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author LongQi
 * @projectName boot-integration
 * @description: TODO
 * @date 2023/3/29 20:06
 */

public class SingleReactorMultiThread{

    public static void main(String[] args) {
        int port = 8080;
        Server server = new Server(port);
        server.start();
        sendMessage(port);
    }

    static class Server{
        private int port;
        public Server(int port){
            this.port=port;
        }
        public void start(){
            try {
                ServerSocketChannel server = ServerSocketChannel.open();
                server.configureBlocking(false);
                server.socket().bind(new InetSocketAddress(port));
                Selector selector = Selector.open();
                // 设置select监听的事件
                server.register(selector, SelectionKey.OP_ACCEPT);
                new Thread(new Reactor(selector)).start();
            }catch (Exception e){
                System.out.println("服务器启动失败:"+e.getMessage());
                e.printStackTrace();
            }
        }
    }

    static class Reactor implements Runnable{
        private Selector selector;
        private Dispatch dispatch = new Dispatch();
        public Reactor(Selector selector){
            this.selector=selector;
        }

        @Override
        public void run() {
            try{
                while (true){
                    int n = selector.select();
                    if(n > 0){
                        Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                        while (iterator.hasNext()){
                            SelectionKey key = iterator.next();
                            dispatch.dispatch(selector,key);
                            iterator.remove();
                        }
                    }
                }
            }catch (Exception e){
                System.out.println("服务器运行异常:"+e.getMessage());
                e.printStackTrace();
            }
        }
    }

    static class Dispatch{
        private Acceptor acceptor = new Acceptor();
        private ThreadPoolExecutor handPool = new ThreadPoolExecutor(200,300,60, TimeUnit.SECONDS,new LinkedBlockingQueue<>(800));

        public void dispatch(Selector selector,SelectionKey key){
            if(key.isAcceptable()){
                acceptor.hand(selector,key);
            }
            if(key.isReadable()){
                handPool.submit(new ReadHandler(key));
            }
        }
    }

    static class Acceptor{
        public void hand(Selector selector,SelectionKey key){
            try{
                ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                SocketChannel clientChannel = serverChannel.accept();
                clientChannel.configureBlocking(false);
                clientChannel.register(selector,SelectionKey.OP_READ);
            }catch (Exception e){
                System.out.println("处理请求异常:"+e.getMessage());
                e.printStackTrace();
            }
        }
    }

    static class ReadHandler implements Runnable{
        private SelectionKey key;
        public ReadHandler(SelectionKey key){
            this.key = key;
        }

        @Override
        public void run() {
            try{
                SocketChannel channel = (SocketChannel) key.channel();
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                while (channel.read(buffer)!=-1){
                    //复位，转化为读模式
                    buffer.flip();
                    while (buffer.hasRemaining()){
                        System.out.println("收到客户端"+channel.socket().getPort()+"的信息："+ StandardCharsets.UTF_8.decode(buffer).toString());
                    }
                    //清空缓存区，转化为写模式
                    buffer.clear();
                }
            }catch (Exception e){
                System.out.println("处理请求异常:"+e.getMessage());
                e.printStackTrace();
            }
        }
    }

    public static void sendMessage(int port) {
        try{
            Thread.sleep(2000);
            ThreadPoolExecutor clientPool = new ThreadPoolExecutor(200,300,60, TimeUnit.SECONDS,new LinkedBlockingQueue<>(800));
            for(int i=0;i<300;i++){
                clientPool.submit(new Runnable() {
                    @Override
                    public void run() {
                        try{
                            Socket client = new Socket();
                            client.connect(new InetSocketAddress("127.0.0.1",port));
                            client.getOutputStream().write(("hello world,send time:"+System.nanoTime()).getBytes());
                            // 注意TCP粘包，这里不调用close，服务器是收不到消息的
                            client.close();
                        }catch (Exception e){
                            System.out.println("客户端发送信息失败");
                        }
                    }
                });
            }
        }catch (Exception e){
            System.out.println("客户端发送信息失败");
        }
    }
}

 多Reactor多线程

       这里NIO Server里有两个Reactor，一个分发给acceptor，一个分发给处理线程。

JavaIO_第五篇：基于NIO的Reactor三种模式
毛毛的专栏
08-14 1262
文章目录一、前言二、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
【后端开发】Reactor 模型详解
Linuxhus的博客
07-28 1789
Reactor模型具有如下优点响应速度快，不必为单个同步事件所阻塞，因为是事件轮询机制可以最大程度的避免复杂的多线程及同步问题，并且避免了多线程/进程的切换开销扩展性好，可以方便的通过增加Reactor实例个数来充分利用CPU资源复用性好，Reactor模型本身与具体事件处理逻辑无关，具有很高的复用性。...
java基于NIO实现Reactor模型源码.zip
06-01
java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码java基于NIO实现Reactor模型源码
Reactor模式和NIO
chnjxiang的专栏
09-06 1312
当前分布式计算　Web Services盛行天下，这些网络服务的底层都离不开对socket的操作。他们都有一个共同的结构：1. Read request2. Decode request3. Process service4. Encode reply5. Send reply经典的网络服务的设计如下图，在每个线程中完成对数据的处理： 但这种模式在用户负载增加时，性能将下降非常的快。我们需要重新寻
java模式之Reactor
atrueman123的专栏
12-20 1122
Java　NIO非堵塞应用通常适用用在I/O读写等方面，我们知道，系统运行的性能瓶颈通常在I/O读写，包括对端口和文件的操作上，过去，在打开一个I/O通道后，read()将一直等待在端口一边读取字节内容，如果没有内容进来，read()也是傻傻的等，这会影响我们程序继续做其他事情，那么改进做法就是开设线程，让线程去等待，但是这样做也是相当耗费资源的。Java NIO非堵塞技术实际是采取Reactor模式，或者说是Observer模式为我们监察I/O端口，如果有内容进来，会自动通知我们，这样，我们就不必开启多个
NIO Reactor模型
weixin_40849725的博客
08-18 570
NIO Reactor模型Reactor三种模型单线程模型多线程模型主从多线程模型Netty线程模型1 线程组2 ChannelPipeline3 异步非阻塞 Reactor模式是基于事件驱动开发的，服务端程序处理传入多路请求，并将它们同步分派给请求对应的处理线程，Reactor模式也叫Dispatcher模式，即I/O多路复用统一监听事件，收到事件后分发（Dispatch给某进程），这是编写高性能网络服务器的必备技术之一。 Reactor模式以NIO为底层支持，核心组成部分包括Reactor和Ha
【NIO系列】——之Reactor模型
weixin_34133829的博客
07-11 1420
在开篇之前，我们对JavaNIO 的使用方式不做过多介绍，这种API的介绍方式网上太多了，没必要详细介绍，我们假设NIO的使用方式，你能够熟练运用。这是NIO系列第三篇:【NIO系列】——之TCP探秘【NIO系列】——之IO模型通过之前的Unix的IO模型介绍，想必也了解到了5种IO模型。java的NIO是属于同步非阻塞IO，关于IO多路复用，java没有相应的IO模型，但有相应的编程模式，Rea...
「NIO系列」——之Reactor模型
lt_xiaodou的博客
07-31 740
通过之前的Unix的IO模型介绍，想必也了解到了5种IO模型。java的NIO是属于同步非阻塞IO，关于IO多路复用，java没有相应的IO模型，但有相应的编程模式，Reactor就是基于NIO中实现多路复用的一种模式。本文将从以下几点阐述Reactor模式reactor是什么为何要用，能解决什么问题如何用，更好的方式其他事件处理模式。...
Java实现的单Reactor模型NIO示例代码
标题中提到的“socket-nio-single-reactor.zip”暗示了一个压缩文件包，其中包含了关于使用Java语言实现的单Reactor模型的网络通信示例代码。NIO是New Input/Output的简称，它在Java中代表一种支持多路复用的非阻塞...
Java NIO实现的Reactor模型源码解析
资源摘要信息: "java基于NIO实现Reactor模型源码.zip" 文件是一个压缩包，包含用于实现Reactor模式的Java源代码。Reactor模式是一种广泛用于构建可扩展的网络应用程序的反应式编程模式，特别是在非阻塞I/O环境下。...
Java NIO之Reactor模型
ystyaoshengting的专栏
02-03 405
Reactor模式思想：分而治之+事件驱动 1）分而治之 一个连接里完整的网络处理过程一般分为accept、read、decode、process、encode、send这几步。 Reactor模式将每个步骤映射为一个Task，服务端线程执行的最小逻辑单元不再是一次完整的网络请求，而是Task，且采用非阻塞方式执行。 2）事件驱动 每个Task对应特定网络事件。当Task准备就绪时，Re...
三、Java NIO 深入解读--Reactor模型
最新发布
qq_41925134的博客
09-03 351
目前存在的线程模型有：传统阻塞 I/O 服务模型Reactor 模式根据 Reactor 的数量和处理资源池线程的数量不同，有 3 种典型的实现单 Reactor 单线程;单 Reactor 多线程;主从 Reactor 多线程Netty 线程模式(Netty 主要基于主从 Reactor 多线程模型做了一定的改进，其中主从 Reactor 多线程模型有多个 Reactor)
【Reactor】学习redis线程模型有感
weixin_30549657的博客
08-10 321
https://my.oschina.net/u/1859679/blog/1844109 该模式可以有简单实现、也可以多线程实现、要看场景，比喻redis的实现就是简单，因为都是基于内存操作。 学习下！ 基于Reactor Pattern 处理模式中，定义以下三种角色: Reactor将I/O事件分派给对应的Handler Acceptor...
NIO Reactor模型
M_Joes_17的博客
08-27 374
经典的I/O服务设计 — BIO模式 这就是经典的每连接对应一个线程的同步阻塞I/O模式。 流程： ① 服务器端的Server是一个线程，线程中执行一个死循环来阻塞的监听客户端的连接请求和通信。 ②当客户端向服务器端发送一个连接请求后，服务器端的Server会接受客户端的请求，ServerSocket.accept()从阻塞中返回，得到一个与客户端连接相对于的Socket。 ③ ...
NIO源码解析-Reactor线程模型
恐龙弟旺仔的博客
09-23 509
前言： 在我们进行网络编程中，为了应对海量的连接及IO处理，多数会采用一种叫做Reactor的处理模型。那么什么是Reactor模型呢？它有什么魔力来处理那么大量的客户端连接呢？与之前提到的NIO，它们是一回事吗？ 1.Reactor组件 Reactor模型基于事件驱动。 什么是事件？客户端的连接、读写，这都可被称为事件。 在Reactor模型中定义了三种角色： 1.1 Acceptor 用于处理客户端的连接，并将连接分发到处理链中 1.2 R...
NIO线程模型之Reactor模型初识
m0_46684016的博客
12-02 296
NIO线程模型 Reactor 是什么 1.事件驱动（event handling） 2.可以处理一个或多个输入源（one or more inputs） 3.通过Service Handler同步的将输入事件（Event）采用多路复用分发给相应的Request Handler（多个）处理 三大核心角色：Reactor Acceptor Handler Reactor：监听事件的发生，并分发给对应的handler处理，或者分发给acceptor Acceptor： 处理客户端建立连接事件，并创建hand
java reactor nio_Java NIO Reactor模式
weixin_29300805的博客
02-24 268
一、NIO介绍：NIO模型：1、Channel为连接通道，相当于一个客户端与服务器的一个连接，Selector为通道管理器，将Channel注册到Selector上，Selector管理着这些Channel，当管理的某个通道有事件到达时，Selector将会通知应用程序去处理；Selector工作的线程和处理网络事件的应用是在不同的线程中；2、NIO 有一个主要的类Selector,这个类似一个观...
NIO-Reactor
少年不识愁滋味
12-12 309
NIO和BIO 多路IO复用 Reactor模式 高性能IO的发展历程:单线程阻塞->多线程并发->事件驱动NIO 单线程阻塞：最大问题是无法并发，效率太低，当前请求没有处理完，后面的请求一直排队等待，通常是一个while循环，accept，有数据后执行，执行完成后执行while下一次循环 多线程并发：一个连接一个线程，缺点是：资源要求太高，系统中创建线程是需要比较高的系统资源的，如果连接数太高，系统无法承受，而且，线程的反复创建-销毁也需要代价。 事件驱动NIO：reactor模型，当有事件触
IO系列学习总结四：NIO的三种reactor模型
avengerEug的博客
03-03 576
前言 上篇文章：IO系列学习总结三：三张图带你了解NIO通信程序的执行流程我们了解了一个普通NIO应用程序的通信执行流程。了解到了NIO的非阻塞具体体现在哪个地方。并对它的Selector、SelectedKey、Channel组件有了基础的了解。在上篇文章中的程序案例中，虽然它解决了BIO的阻塞问题，但它的吞吐量还不是特别高，因为它是单线程的。对于selector而言，它的工作太繁重了，需要管理服务端ServerSocketChannel的accept事件，还要管理连接到服务端的SocketChanne
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

龙行天下_LXTX

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值