Reactor模式和NIO

最新推荐文章于 2023-09-03 15:35:02 发布
最新推荐文章于 2023-09-03 15:35:02 发布
阅读量6.3k 收藏 9
点赞数 1
分类专栏： netty 文章标签： java netty socket reactor nio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u022812849/article/details/111301705
版权

Reactor模式

不管是普通的WEB服务还是分布式服务，它们都有一个相似的结构，可以分为五个部分：

  1. 接收请求：通过IO从网络中读取到请求的字节流。
  2. 解码请求：将字节流转换为我们熟悉的请求对象。
  3. 处理服务：通过得到的请求对象，执行一些业务逻辑。
  4. 编码响应：将我们要响应的对象编码成通过网络传输的字节流。
  5. 发送响应：通过IO将响应字节流发送到网络中。

通过以上五步，我们可以轻松看到，IO在网络服务中起着举足轻重的作用。

传统的服务设计

在这里插入图片描述

每个handler都有自己的一个线程，处理来自一个客户端的请求，可以想象客户端数量巨大时，创建的线程开销非常大，同时线程上下文切换的成本也很高。

package com.morris.reactor;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

// Classic Service Designs
// 以下示例代码不考虑异常处理
public class ClassicServerSocket implements Runnable {
    private int port;
    private ServerSocket socket;

    public ClassicServerSocket(int port) throws IOException {
        this.port = port;
        socket = new ServerSocket(port);
    }

    @Override
    public void run() {
        while (!Thread.interrupted()) {
            // 阻塞直到接收到连接请求
            Socket client = null;
            try {
                client = socket.accept();
            } catch (IOException e) {
                e.printStackTrace();
            }
            // 为该客户端的连接开一个线程
            new Thread(new Handler(client)).start();
        }
    }

    private class Handler implements Runnable {
        private Socket socket;

        public Handler(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            // 自定义代码逻辑（对应网络服务基本的五步）
        }
    }
}

高伸缩性的目标

  • 当负载增大时能优雅的降级服务。
  • 当资源（CPU、内存、磁盘、带宽）提升时能优化服务。
  • 低延迟。
  • 能应对徒增的请求。
  • 可以调控的服务质量。

可以用分治法来实现上面的目标，思路就是将一个处理过程分为很多非阻塞的多个小任务，每个任务在被允许的时候就去执行它。

以上就是一个事件驱动的设计，事件驱动设计使用的资源更少，不用针对每个请求启用一条线程，减少了上下文切换，减少了阻塞。但是任务分发可能会更慢，而且必须手动将事件和对应的处理动作绑定，相应的编程实现也会更难。

Reactor模式

Reacto模式就是事件驱动的设计，它按照发生的IO事件类型，将其分发到该事件对应的Handler处理，在Handler中执行的是一些非阻塞操作。

在这里插入图片描述

一个线程实现的最基本的Reactor模式代码如下：

package com.morris.reactor;

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;

public class Refactor implements Runnable {
    final Selector selector;
    final ServerSocketChannel serverSocket;

    public Refactor(int port) throws IOException {
        selector = Selector.open();
        serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress(port));
        serverSocket.configureBlocking(false);
        // 监听ACCEPT事件
        SelectionKey sk = serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        // 绑定ACCEPT事件对应的处理单元Acceptor
        sk.attach(new Acceptor());
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                // 发生一直阻塞直到有事件
                selector.select();
                Set<SelectionKey> selected = selector.selectedKeys();
                Iterator<SelectionKey> it = selected.iterator();
                // 处理所有已发生事件
                while (it.hasNext()) {
                    // 将事件分发给对应的处理单元
                    dispatch(it.next());
                }
                selected.clear();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    void dispatch(SelectionKey k) {
        // 获得已经绑定的处理单元
        Runnable r = (Runnable) (k.attachment());
        if (r != null) {
            // 执行处理单元
            r.run();
        }
    }

    class Acceptor implements Runnable {
        @Override
        public void run() {
            try {
                SocketChannel c = serverSocket.accept();
                if (c != null) {
                    // 用得到的socket，new一个读事件的处理单元
                    new BasicDesignHandler(selector, c);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    final class BasicDesignHandler implements Runnable {
        private static final int MAXIN = 1024;
        private static final int MAXOUT = 1024;
        final SocketChannel socket;
        final SelectionKey sk;
        ByteBuffer input = ByteBuffer.allocate(MAXIN);
        ByteBuffer output = ByteBuffer.allocate(MAXOUT);
        static final int READING = 0, SENDING = 1;
        int state = READING;

        BasicDesignHandler(Selector selector, SocketChannel socket) throws IOException {
            this.socket = socket;
            socket.configureBlocking(false);
            sk = socket.register(selector, 0);
            // 绑定本处理单元对象
            sk.attach(this);
            sk.interestOps(SelectionKey.OP_READ);
            selector.wakeup();
        }

        boolean inputIsComplete() {
            /* ... */
            return true;
        }

        boolean outputIsComplete() {
            /* ... */
            return true;
        }

        void process() {
            /* ... */
        }

        @Override
        public void run() {
            try {
                if (state == READING) {
                    read();
                } else if (state == SENDING) {
                    send();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        void read() throws IOException {
            socket.read(input);
            if (inputIsComplete()) {
                process();
                state = SENDING;
                sk.interestOps(SelectionKey.OP_WRITE);
            }
        }

        void send() throws IOException {
            socket.write(output);
            if (outputIsComplete()) {
                sk.cancel();
            }
        }
    }
}

上面的BasicDesignHandler可以改造为如下：

final class BasicDesignHandler implements Runnable {
    private static final int MAXIN = 1024;
    final SocketChannel socket;
    final SelectionKey sk;
    ByteBuffer input = ByteBuffer.allocate(MAXIN);
    static final int READING = 0, SENDING = 1;
    int state = READING;

    BasicDesignHandler(Selector selector, SocketChannel socket) throws IOException {
        this.socket = socket;
        socket.configureBlocking(false);
        sk = socket.register(selector, 0);
        // 绑定本处理单元对象
        sk.attach(this);
        sk.interestOps(SelectionKey.OP_READ);
        selector.wakeup();
    }

    boolean inputIsComplete() {
        /* ... */
        return true;
    }

    void process() {
        /* ... */
    }

    @Override
    public void run() {
        try {
            socket.read(input);
            if (inputIsComplete()) {
                process();
                state = SENDING;
                sk.attach(new Sender());
                sk.interestOps(SelectionKey.OP_WRITE);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    final class Sender implements Runnable {

        private static final int MAXOUT = 1024;
        ByteBuffer output = ByteBuffer.allocate(MAXOUT);

        boolean outputIsComplete() {
            /* ... */
            return true;
        }

        @Override
        public void run() {
            try {
                socket.write(output);
                if (outputIsComplete()) {
                    sk.cancel();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
morris131
关注
专栏目录
Reactor模式及NIO
GeekDengshuo
05-27 441
文章目录Reactor模式及NIO1.引子2.Reactor模式2.1Reactor模式定义2.2网络编程模型2.3Reactor常用组件3.Reactor模式应用3.1多线程IO模型3.2单线程Reactor模型附录参考文章 Reactor模式及NIO 1.引子 Redis服务器: Redis服务器是一个事件驱动程序,主要处理文件事件(file event)和时间事件(time event) Redis基于Reactor模式开发了网络事件处理器 2.Reactor模式 2.1Reactor模式定义 The
Reactor 模式和 Java NIO
m0_67698950的博客
07-06 295
本文先从基本的 Socket 编程模式说起，介绍了 Java 传统的同步阻塞 IO 网络编程的基本实现，以及存在的性能问题，从而引出 Reactor 设计模式，最后通过 Java NIO 给出单 Reactor 单线程的实现方案。在 Unix/Linux 环境下，网络中的进程通过 Socket 进行通信，Socket 本质上也是一种特殊的文件，可以按照“打开，读写，关闭”的模式来操作。Socket 编程的基本模式如图 1 所示：创建 socket：本质上就是创建一个文件，每个文件都有一个整型的文件描述符（f
Reactor — NIO原理以及Reactor模式
qq_38658567的博客
07-27 1046
一、JAVA NIO NIO主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector。传统IO基于字节流和字符流进行操作，而NIO基于Channel和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择区)用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个线程可以监听多个数据通道。 NIO和传统IO（一下简称IO）之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从
Reactor的NIO线程模型
微信公众号：大数据从业者
11-15 134
1.Reactor单线程模型 传统的javaNIO通信的线程模型。该线程模型仅有一个I/O线程处理所有的I/O操作，如下图： 单线程模型的Reactor 所有的客户端都连接到一个I/O线程负责的Acceptor上，连接成功后，由Reactor里的Dispatch将接收的ByteBuffer分发到指定的Handler上处理，进行解码，业务处理，编码及发送给客户端等过程。整个过程I/O线...
「NIO系列」——之Reactor模型
lt_xiaodou的博客
07-31 663
通过之前的Unix的IO模型介绍，想必也了解到了5种IO模型。java的NIO是属于同步非阻塞IO，关于IO多路复用，java没有相应的IO模型，但有相应的编程模式，Reactor就是基于NIO中实现多路复用的一种模式。本文将从以下几点阐述Reactor模式reactor是什么为何要用，能解决什么问题如何用，更好的方式其他事件处理模式。...
reactor:NIO 编程模型 - Reactor，各版本实现
05-29
依据 Doug Lea 的 基于 NIO 实现的 Reacotr 模式的回显服务器 BasicHandler: 单线程处理器 MultiReactor: 主从 Reactor MultithreadHandler: 线程池处理器 Reactor: 接收连接，I/O 读写 Reactor 模型的说明： ...
NIO之Reactor模式
guanhang89的专栏
10-01 797
NIO之Reactor模式 Reactor模式是为了构建一个高性能的服务器端而采用的模式，它采用事件驱动的方式，能够有效应对高并发的场景。NIO也就是非阻塞IO，JDK网络NIO中的Selector的理念也是来自于Reactor模式，了解了Reactor模式，能够让我们更快地对JDK、netty或者其他框架的NIO的实现快速上手 Reactor模式的解释 Reactor模式源自Schmidt的一篇...
【Reactor】学习redis线程模型有感
weixin_30549657的博客
08-10 288
https://my.oschina.net/u/1859679/blog/1844109 该模式可以有简单实现、也可以多线程实现、要看场景，比喻redis的实现就是简单，因为都是基于内存操作。 学习下！ 基于Reactor Pattern 处理模式中，定义以下三种角色: Reactor将I/O事件分派给对应的Handler Acceptor...
Reactor模式与NIO
zy499055759的专栏
06-22 768
这里写自定义目录标题Reactor模式与NIO简单的NIO编程方式Reactor模式单线程Reactor模式多线程Reactor模式主从Reactor多线程模型 Reactor模式与NIO NIO是非阻塞IO，而Reactor是基于NIO的一种设计模式。 简单的NIO编程方式 简单的NIO编程方式其实是以面向过程的方式编写代码的。 public class ChargenServer { public static void main(String[] args) { byte[] rotation
三、Java NIO 深入解读--Reactor模型
最新发布
qq_41925134的博客
09-03 254
目前存在的线程模型有：传统阻塞 I/O 服务模型Reactor 模式根据 Reactor 的数量和处理资源池线程的数量不同，有 3 种典型的实现单 Reactor 单线程;单 Reactor 多线程;主从 Reactor 多线程Netty 线程模式(Netty 主要基于主从 Reactor 多线程模型做了一定的改进，其中主从 Reactor 多线程模型有多个 Reactor)
第五篇：基于NIO的Reactor三种模式
毛毛的专栏
08-14 1114
文章目录一、前言二、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模式和NIO(转载)
深思千年
07-17 1538
本文可看成是对Doug Lea Scalable IO in Java 一文的翻译。      当前分布式计算　Web Services盛行天下，这些网络服务的底层都离不开对socket的操作。他们都有一个共同的结构： 1. Read request 2. Decode request 3. Process service 4. Encode reply 5. Send reply
java模式之Reactor
atrueman123的专栏
12-20 1073
Java　NIO非堵塞应用通常适用用在I/O读写等方面，我们知道，系统运行的性能瓶颈通常在I/O读写，包括对端口和文件的操作上，过去，在打开一个I/O通道后，read()将一直等待在端口一边读取字节内容，如果没有内容进来，read()也是傻傻的等，这会影响我们程序继续做其他事情，那么改进做法就是开设线程，让线程去等待，但是这样做也是相当耗费资源的。Java NIO非堵塞技术实际是采取Reactor模式，或者说是Observer模式为我们监察I/O端口，如果有内容进来，会自动通知我们，这样，我们就不必开启多个
Reactor模型的Java NIO实现
TheLudlows的博客
07-20 3868
之前写的Reactor模型文章只是最基本的单线程模式，此外还有两种基于多线程的Reactor模型，分别为单线程模型和单Reactor多线程模型和多Reactor多线程模型。下面分别介绍。 1.单线程模型 因为之前的文章就是此类型，在此只介绍一种简单的实现。 Server端 public class Reactor1 { public static void main(Stri...
java网络编程(三)----同步非阻塞nio及reactor模型
一个博客
09-05 4246
很多刚接触NIO的人，第一眼看到的就是Java相对晦涩的API，比如：Channel，Selector，Socket什么的；然后就是一坨上百行的代码来演示NIO的服务端Demo，所以这里我们人性化地简单介绍一下。 NIO我们一般认为是New I/O（也是官方的叫法），因为它是相对于老的I/O类库新增的（其实在JDK 1.4中就已经被引入了，但这个名词还会继续用很久，即使它们在现在看来已经是“旧”
Java NIO reactor模式解析与实战
反应器模式（Reactor Pattern）是Java NIO中的一种设计模式，它是一种事件驱动的设计模式，用于处理大量并发事件。在NIO中，反应器主要负责监听和分发网络连接事件，当一个连接有新的读写事件发生时，反应器会将事件...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

morris131

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

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

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

打赏作者

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

抵扣说明：

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

余额充值