Netty之Reactor线程模型

最新推荐文章于 2023-03-23 15:00:11 发布
最新推荐文章于 2023-03-23 15:00:11 发布
阅读量172 收藏
点赞数
分类专栏： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c_c_y_CC/article/details/104976975
版权

Reactor 线程模型

一、传统线程模型与NIO模型

1. BIO 模型

传统 I/O 模型为同步阻塞式 I/O 模型，对于网络I/O而言，需要赋予每个连接一个线程，同时该线程会阻塞于I/O事件，无法操作执行其他任务

在这里插入图片描述

1.1 处理模型

每当有新连接到来时，创建一个新的线程以对新连接进行处理，可用***线程池***进行优化，但仍然无法应对高并发服务

1.2 服务端代码
public class BIOServer {

    private ServerSocket serverSocket;
    private ExecutorService executorService;

    // 初始化 server 端
    public BIOServer() {
        try {
            System.out.println("服务器开始启动");
            init();
        } catch (IOException e) {
            System.out.println("服务器启动失败");
            e.printStackTrace();
            // 启动失败，退出服务器
            System.exit(0);
        }
    }

    private void init() throws IOException {
        // 创建 serverSocket
        serverSocket = new ServerSocket(9999);
        // 实例化线程池，优化BIO的线程使用效率
        executorService = Executors.newFixedThreadPool(4);
        System.out.println("服务器初始化成功");
    }

    public void start() {
        while (true) {
            try  {
                final Socket socket = serverSocket.accept();
                System.out.println("收到来自客户端的连接");
                // 使用 lambda 表达式
                executorService.execute(() -> {
                    handler(socket);
                });
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    // 对连接的处理
    private void handler(Socket socket) {
        System.out.println("线程："+Thread.currentThread().getName());
        System.out.println("读取数据 ==> start");
        byte[] bytes = new byte[1024];
        int read;
        try {
            InputStream inputStream = socket.getInputStream();
            while ((read = inputStream.read(bytes)) != -1) {
                System.out.print(new String(bytes, 0, read));
            }
            System.out.println("读取数据 ==> finish");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
2. NIO 模型

NIO 为同步非阻塞式 IO，属于事件驱动模式，类似于 java的swing 或者时html页面的事件。一个线程管理多个 I/O 通道（简单的单线程reactor模型），每当检测出某些通道有事件发生时，才对其触发的事件进行处理。

在这里插入图片描述

1. 处理模型
  1. 新连接到来时，即serverSocketChannel的连接事件发生时，接收连接，并将客户端管道注册到selector中进行监听
  2. 当客户端通道有读事件发生时，对读事件进行处理
2. 服务端代码
public class NIOServer {

    ServerSocketChannel serverSocketChannel;
    Selector selector;

    // 默认端口
    private static final int DEFAULT_PORT = 12345;

    public NIOServer() {
        this(DEFAULT_PORT);
    }

    public NIOServer(int port) {
        try {
            init(port);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("初始化异常");
            System.exit(0);
        }
    }


    private void init(int port) throws IOException {
		// 创建服务端管道
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress(port));
        // 设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        selector = Selector.open();
        // 将serverSocketChannel注册到selector，监听accept操作
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    }

    public void start() {
        try {
            inStart();
        } catch (Exception e) {
            System.out.println("服务器无法正常启动");
            e.printStackTrace();
        }
    }

    private void inStart() throws IOException, InterruptedException {

        while (true) {
            // 非阻塞式获取发生事件的管道
            if (selector.select(1000) == 0) {
                // System.out.println("server 无事件");
                // 每一秒检查一次
                Thread.sleep(1000);
            } else {
                // 获取有事件发生的SelectionKey
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    // 移除当前key, 防止重复操作
                    iterator.remove();
                    if (key.isAcceptable()) {
                        acceptHandler();
                    }
                    if (key.isReadable()) {
                        readHandler(key);
                    }
                }
            }
        }
    }

    /**
     * 对读事件进行处理
     */
    private void readHandler(SelectionKey key) throws IOException {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        ByteBuffer attachment = (ByteBuffer) key.attachment();
        // 进行读操作
        System.out.println("接收到客户端[ " +
                socketChannel.getRemoteAddress() + " ]的信息：");
        while (true) {
            int l = socketChannel.read(attachment);
            if (l == 0) {
                break;
            }
            if (l == -1) {
                System.out.println("客户端[ " + socketChannel.getRemoteAddress() + " ]断开连接");
                key.cancel();
                break;
            }
            attachment.flip();
            System.out.print(new String(attachment.array(), 0, attachment.limit()));
            attachment.clear();
        }
        System.out.println();
    }

    /**
     * 对读事件进行处理
     */
    private void acceptHandler() throws IOException {

        SocketChannel socketChannel;
        while ((socketChannel = serverSocketChannel.accept()) == null) ;
        // 将socketChannel设置为非阻塞
        socketChannel.configureBlocking(false);
        // 将SocketChannel注册到selector,并绑定buffer
        socketChannel.register(selector,
                SelectionKey.OP_READ, ByteBuffer.allocate(1024));
        System.out.println("成功连接客户端:" + socketChannel.getRemoteAddress());
    }
}
3. 客户端代码
public class NIOClientApplication {

    public static void main(String[] args) throws IOException, InterruptedException {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);
        // 连接到服务器，十秒内连接不上则退出客户端
        if (!socketChannel.connect(new InetSocketAddress(12345))) {
            for (int i = 0; i < 10; i++) {
                Thread.sleep(1000);
                if (socketChannel.finishConnect()) {
                    break;
                }
            }
            if (!socketChannel.finishConnect()) {
                System.out.println("连接出错，请稍后重连");
                System.exit(0);
            }
        }
        String msg = "hello, I am ccy";
        System.out.println(msg.getBytes().length);
        ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
        socketChannel.write(buffer);
        Thread.sleep(4000);
        String msg1 = "hello, I am ccy2";
        ByteBuffer buffer1 = ByteBuffer.wrap(msg1.getBytes());
        socketChannel.write(buffer1);
        Thread.sleep(2000);
        socketChannel.close();
    }
}

二、Reactor线程模型

Reactor线程模型基于NIO事件驱动进行实现，每当有事件发生时，将其进行分发。有三种实现，分别是***单线程 Reactor模型 、多线程 Reactor模型 、主从多线程 Reactor模型***

1. 单线程 Reactor 模型

与NIO模型相同

在这里插入图片描述

2. 多线程 Reactor 模型

当客户端连接到服务器时，reactor负责读取数据并将数据交由工作线程处理，待处理完成之后由reactor将数据会送给客户端

在这里插入图片描述

3. 主从 Reactor 模型

主Reactor负责监听serverSocketChannal的连接事件，当收到客户端连接时，将连接注册到从reactor中，由从reactor负责处理客户端的读写事件

在这里插入图片描述

后续更新Reactor模型代码
c_c_y_CC
关注
专栏目录
Netty Reactor 线程模型
悟已往之不谏，知来者之可追
12-22 287
Reactor 线程模型是 Netty 实现高性能的核心所在，在 Netty 中 EventLoop 是 Reactor 线程模型的核心处理引擎，那么 EventLoop 到底是如何实现的呢？又是如何保证高性能和线程安全性的呢？ 说明：本文参考的 Netty 源码版本为 4.1.42.Final。 Reactor 线程执行的主流程 因为 Netty 是基于 NIO 实现的，所以推荐使用 NioEventLoop 实现，我们再次通过 NioEventLoop 的核心入口 run() 方法回顾 Netty
Netty Reactor面试连环问
最新发布
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
08-27 847
笔者分别带入索引0、5、8，进行与运算时，真正参与的二进制永远是和永远是7以内的进制，得出的结果分别是0、5、0，永远不会越界，并且运算性能还能得到保证。中查看是否有继续的任务，如果有则查看它的到期时间，并基于这个时长查询是否存在就绪的任务。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。
Netty的Reactor线程模型
xiaomin1991222的专栏
09-17 192
  上图是一个Reactor线程模型，基于select(),epoll()，Reactor线程将I/O调用请求和I/O操作分离开，理论上一个Reactor线程能处理N个网络I/O操作，但是当并发量很大的时候，一个Reactor线程就会出现响应缓慢，连接超时等问题。==========================================================...
Netty线程模型 - Reactor 模式
zhj52666的博客
11-09 363
我相信有很多人会对这个Reactor模式比较陌生，但是Netty这个名字大家都会比较熟悉，即使没有学习使用过，也会对它有所耳闻，它可以说是Java高性能网络编程的代名词。Reactor模式就是Netty线程模型设计的核心，本文我们就以Reactor模式入手，探究一下经典的设计。
Netty线程模型 Reactor模型
清风
11-07 474
线程模型 线程模型有传统阻塞I/O服务器模型和Reactor模型(网络主流模型) 根据Reactor的数量和处理资源池线程的数量不同，有3种典型的实现： 单Reactor单线程 单Reactor多线程 主从Reactor多线程 Netty基于主从Reactor多线程模型，并做了一些改进，其中主从Reactor多线程有多个Reactor 单线程Reactor模型 Java的NIO模式的Selector网络通讯，其实就是一个简单的Reactor模型。可以说是Reactor模型的朴素原型。 .
Netty核心精讲之Reactor线程模型源码分析.mp4
06-21
在深入探讨Netty的Reactor线程模型源码之前，我们需要先理解Reactor模式的基本概念。 Reactor模式是一种设计模式，常用于处理并发I/O事件。在多路复用I/O（如epoll、kqueue）中，Reactor模式是关键组成部分，它负责...
简单了解Java Netty Reactor三种线程模型
12-20
在Netty中，Reactor线程模型是其核心设计之一，用于处理并发连接和网络I/O操作。本文将详细介绍Reactor的三种线程模型，并结合Netty的线程模型进行解析。 ### 1. Reactor 单线程模型 Reactor单线程模型是指所有的I...
（java）netty框架—reactor线程模型详解
sylnb的博客
03-23 670
负责，线程池可以采用标准的JDK线程池实现，它包含一个任务队列和N个可用的线程，由这些NIO线程负责消息的读取、解码、编码和发送。缺点：多线程数据共享和访问比较复杂， reactor 处理所有的事件的监听和响应，在单线程运行， 在高并发场景容易出现性能瓶颈.使用场景：客户端的数量有限，业务处理非常快速，比如 Redis 在业务处理的时间复杂度 O(1) 的情况。​ 一个NIO线程可以同时处理N条链路，但是一个链路只对应一个NIO线程，防止发生并发操作问题。优点：可以充分的利用多核 cpu 的处理能力。
Netty学习二十：源码分析之Netty Reactor 线程模型
weixin_41402069的博客
07-14 652
Netty学习系列
Netty Reactor线程模型
NullPointerException的博客
06-28 330
前两篇博文分别介绍了Java 线程模型：BIO NIO和Reactor线程模型，本篇博文将介绍Reactor线程模型在Netty中的实际应用。 Netty模型 Netty模型的简单介绍 Netty 主要基于主从 Reactors 多线程模型做了一定的改进，其中主从 Reactor 多线程模型有多个 Reactor。 BossGroup 线程维护 Selector , 只关注 Accecpt； 当接收到Accept事件，获取到对应的SocketChannel,封装成NIOScoketChannel并注.
Netty 线程模型（Reactor 线程模型）
程序猿进阶
12-14 4130
[Netty 线程模型（Reactor 线程模型） 当说到 Netty 线程模型的时候，一般首先会想到经典的 Reactor 线程模型，尽管不同的 NIO 框架对于 Reactor 模式的实现存在差异，但本质上还是遵循了 Reactor 的基础线程模式。 一、Reactor 单线程模型 无论是C++ 还是 Java 编写的网络框架，大多数都是基于 Reactor 模型进行设计和开发，Reactor 模型基于事件驱动，特别适合海量的 I/O 事件。 【1】Reactor 单线程模型，是指所有的 I/
Netty(一) Reactor 线程模型
qq_32092237的博客
09-20 144
什么是Reactor模型 Reactor模式含义为反应堆模式，专门用于处理请求的模式，它基于IO多路复用和事件驱动。 通过1个或多个线程接收请求，然后将请求转发至其他工作线程进行业务处理。Reactor模式适用于高并发场景，替代传统的多线程模式，提升系统的资源，提升吞吐量； 处理并发请求的技术历史 单线程处理 一个线程处理请求，后续请求排队阻塞，等前一个请求处理完才能处理后续请求连接 1个连接，1个线程 每来一个连接，就分配一个线程用于处理这个连接。由于资源限制，且频繁创建线程的消耗，引入了线程池对线程资源
netty - 线程模型 reactor
u012391423的博客
07-19 1236
目录 线程模型 1、传统IO服务模型 2、Reactor模式 reactor 三种模式： 总结 netty模型 执行流程简述 线程模型 1、传统IO服务模型 阻塞的IO模式获取输入数据，每个链接需要独立的线程完成数据传输及处理 当并发数较大时，创建大量线程，占用系统资源；线程创建后如无数据读写，将被阻塞 2、Reactor模式 reactor 针对传统的IO模型的两个缺点，解决方案： a、基于IO多路复用模型：多个连接共用一个阻塞对象。应用程序只需要在一.
Netty Reactor 线程模型（随记）
无怨无悔专栏
02-21 211
Netty被称为一个高性能、高可扩展性能的异步事件驱动的网络应用程序框架，它极大地简化了TCP和UDP客户端和服务器开发等网络编程。 Netty的Reactor模型中有四个核心概念： Resources资源（请求和任务） Synchronous Event Demultiplexer同步事件复用器 Dispatcher 分配器 Request Hand...
Netty框架之Reactor线程模型
wzs535131的博客
07-19 339
作为一个程序员，平时少不了要学习新的东西，最近学习Netty框架，Netty是由JBOSS提供的一个java开源框架，Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。Netty 是一个基于NIO的客户、服务器端的编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，Netty简化和流线化了网络应用的编程开发过程。 Netty就是基于Reactor线程模型开发的，我们今天来简单分析下： Reactor模型...
Netty源码分析系列之Reactor线程模型
天堂的博客
12-02 404
什么是Reactor线程模型？Netty作为一款高性能的网络框架，其底层使用的网络IO模型是什么呢？
Netty源码解析之Reactor线程模型
|-| [- |_ |_ ()
07-04 468
文章目录前言线程组的初始化发动机线程的初始化发动机启动select流程：轮询Channel上的事件selector空轮询BUGprocessSelectedKeys：处理事件服务端Channel处理事件一个新连接到服务端之后会发生什么事？客户端Channel处理事件runAllTasks：运行所有任务拿到定时任务执行任务Reactor线程模型 前言 个人认为，Netty中最核心的就是它的线程模型了...
Netty学习——Reactor线程模型
Luffyu的博客
04-21 246
一 netty概述 1.1 为什么有了NIO还有Netty NIO的缺点 JDK 的 NIO 底层由 epoll 实现，该实现饱受诟病的Selector 空轮询 bug 会导致 cpu 飙升 100% NIO的API繁杂，使用麻烦，必须熟练掌握Selector、Channel、Buffer等相关API。并且需要熟练Java多线程编程和网络编程，才能写出高质量的NIO代码。 开发工作量和难度都...
Netty线程模型深度解析：从Reactor到NioEventLoop
Netty采用了主从多线程模型的变种，其核心组件是NioEventLoop。Netty中的NioEventLoop组成了一个线程组，每个NioEventLoop负责处理一部分连接。新连接进来后，会被分配给不同的NioEventLoop进行处理，这样可以确保...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值