[Redis]事件驱动模型

最新推荐文章于 2024-06-09 14:39:52 发布
最新推荐文章于 2024-06-09 14:39:52 发布
阅读量231 收藏 1
点赞数 1
分类专栏： Redis 学习总结 文章标签： redis epoll select 事件驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013161278/article/details/113365895
版权

[Redis]事件驱动模型


Redis是如何工作的？我们常说的 事件驱动、 IO多路复用具体是怎么进行落地实现的？下面通过Redis源码进行学习和剖析一看究竟。

源码剖析

main()主方法入口

int main(int argc, char **argv) {
    /*
     *  此处省略一系列系统初始化工作
     */

    // 初始化事件处理器前置函数
    aeSetBeforeSleepProc(server.el,beforeSleep);
    
    // 运行事件处理器，一直到服务器关闭为止
    aeMain(server.el);

    // 服务器关闭，停止事件循环
    aeDeleteEventLoop(server.el);

    return 0;
}

在redis.c中可以找到主方法main()入口，在主方法中一系列的系统初始化工作之后的方法末端，有aeMain(server.el)方法，这里的server.el是aeEventLoop 对象引用，它是对服务器定义事件的封装。

aeEventLoop事件处理封装类

* State of an event based program 
 *
 * 事件处理器的状态
 */
typedef struct aeEventLoop {
    // 目前已注册的最大描述符
    int maxfd;   /* highest file descriptor currently registered */
    // 目前已追踪的最大描述符
    int setsize; /* max number of file descriptors tracked */
    // 用于生成时间事件 id
    long long timeEventNextId;
    // 最后一次执行时间事件的时间
    time_t lastTime;     /* Used to detect system clock skew */
    // 已注册的文件事件
    aeFileEvent *events; /* Registered events */
    // 已就绪的文件事件
    aeFiredEvent *fired; /* Fired events */
    // 时间事件
    aeTimeEvent *timeEventHead;
    // 事件处理器的开关
    int stop;
    // 多路复用库的私有数据
    void *apidata; /* This is used for polling API specific data */
    // 在处理事件前要执行的函数
    aeBeforeSleepProc *beforesleep;
} aeEventLoop;

aeEventLoop封装了服务器事件属性，是一个事件载体

aeCreateEventLoop()事件初始化

/*
 * 初始化事件处理器状态
 */
aeEventLoop *aeCreateEventLoop(int setsize) {
    aeEventLoop *eventLoop;
    int i;

    // 创建事件状态结构
    if ((eventLoop = zmalloc(sizeof(*eventLoop))) == NULL) goto err;

    // 初始化文件事件结构和已就绪文件事件结构数组
    eventLoop->events = zmalloc(sizeof(aeFileEvent)*setsize);
    eventLoop->fired = zmalloc(sizeof(aeFiredEvent)*setsize);
    if (eventLoop->events == NULL || eventLoop->fired == NULL) goto err;
    // 设置数组大小
    eventLoop->setsize = setsize;
    // 初始化执行最近一次执行时间
    eventLoop->lastTime = time(NULL);

    // 初始化时间事件结构
    eventLoop->timeEventHead = NULL;
    eventLoop->timeEventNextId = 0;

    eventLoop->stop = 0;
    eventLoop->maxfd = -1;
    eventLoop->beforesleep = NULL;
    if (aeApiCreate(eventLoop) == -1) goto err;

    /* Events with mask == AE_NONE are not set. So let's initialize the
     * vector with it. */
    // 初始化监听事件
    for (i = 0; i < setsize; i++)
        eventLoop->events[i].mask = AE_NONE;

    // 返回事件循环
    return eventLoop;

err:
    if (eventLoop) {
        zfree(eventLoop->events);
        zfree(eventLoop->fired);
        zfree(eventLoop);
    }
    return NULL;
}

Redis定义了三种文件事件状态

状态定义状态类型
AE_NONE 未设置
AE_READABLE 可读
AE_WRITABLE可写
  • 初始化文件事件（event）结构、已就绪文件事件（fired ）结构数组
    • 分别使用连续数组来存储事件信息
      eventLoop->events = zmalloc(sizeof(aeFileEvent)*setsize);
      eventLoop->fired = zmalloc(sizeof(aeFiredEvent)*setsize);
    • 数组长度为setsize，通过aeCreateEventLoop(server.maxclients+CONFIG_FDSET_INCR)创建
      • maxclients代表用户配置的最大连接数，可在启动时由–maxclients指定，默认为10000。
      • CONFIG_FDSET_INCR 大小为128，目的是给Redis预留一些安全空间。
  • 初始化监听事件
    将事件状态全部初始化成未设置状态
    for (i = 0; i < setsize; i++)
    eventLoop->events[i].mask = AE_NONE;

aeMain() 主循环函数

/*
 * 事件处理器的主循环
 */
void aeMain(aeEventLoop *eventLoop) {

    eventLoop->stop = 0;

    while (!eventLoop->stop) {

        // 如果有需要在事件处理前执行的函数，那么运行它
        if (eventLoop->beforesleep != NULL)
            eventLoop->beforesleep(eventLoop);

        // 开始处理事件，这里是处理所有Redis定义的事件类型，即文件事件、时间事件
        aeProcessEvents(eventLoop, AE_ALL_EVENTS);
    }
}

aeMain()事件处理主方法位于ae.c文件中，这里是通过一个主循环轮询处理aeProcessEvents()方法进行所有系统事件处理，也就是常说的Redis是单线程的原因。

Redis定义了两种事件类型

事件定义事件类型
AE_FILE_EVENTS文件事件
AE_TIME_EVENTS时间事件
AE_ALL_EVENTS所有事件，即文件事件 + 时间事件

aeProcessEvents()事件处理函数

在这里插入图片描述

  • 时间事件
    • 允许阻塞模式&时间事件：根据时间事件判断文件事件阻塞时长或一直阻塞
    • 不允许阻塞模式：非阻塞模式进行
    • aeSearchNearestTimer()链表存储时间事件，此处查找时间复杂度是O(n)
  • 文件事件
    • aeApiPoll() 获取文件事件。Redis根据OS的不同会进行select、epoll、kqueue、evport四种事件函数库的选择，在初始化阶段根据OS的不同进行判断选择最为合适的事件函数库作为事件获取方式，这也是多路复用的重要组成之一。 选择优先级为evport > epoll > kqueue > select。
    • rfileProc() 处理文件读状态事件
    • wfileProc()处理文件写状态事件
  • 事件调度
    • 文件事件的阻塞时间是通过时间事件协调进行控制的。这样既可以不长时间进行阻塞在文件事件的等待处理上，又可以有一定的阻塞减少线程空轮询耗费线程资源
    • 时间事件是周期性、较为稳定出现的，而文件事件是随机性、不稳定出现的。这里是通过稳定的时间事件来协调不稳定的文件事件阻塞等待或非阻塞轮询
    • 对文件事件、时间事件的处理都是同步、有序、原子方式进行的，两种事件类型在单线程的执行下共同协作完成的，因此对两种事件的执行和处理需要额外关注，一旦有一方出现阻塞或长时间执行则会影响整个Redis服务性能
/* Process every pending time event, then every pending file event
 * (that may be registered by time event callbacks just processed).
 *
 * 处理所有已到达的时间事件，以及所有已就绪的文件事件。
 *
 * Without special flags the function sleeps until some file event
 * fires, or when the next time event occurs (if any).
 *
 * 如果不传入特殊 flags 的话，那么函数睡眠直到文件事件就绪，
 * 或者下个时间事件到达（如果有的话）。
 *
 * If flags is 0, the function does nothing and returns.
 * 如果 flags 为 0 ，那么函数不作动作，直接返回。
 *
 * if flags has AE_ALL_EVENTS set, all the kind of events are processed.
 * 如果 flags 包含 AE_ALL_EVENTS ，所有类型的事件都会被处理。
 *
 * if flags has AE_FILE_EVENTS set, file events are processed.
 * 如果 flags 包含 AE_FILE_EVENTS ，那么处理文件事件。
 *
 * if flags has AE_TIME_EVENTS set, time events are processed.
 * 如果 flags 包含 AE_TIME_EVENTS ，那么处理时间事件。
 *
 * if flags has AE_DONT_WAIT set the function returns ASAP until all
 * the events that's possible to process without to wait are processed.
 * 如果 flags 包含 AE_DONT_WAIT ，
 * 那么函数在处理完所有不许阻塞的事件之后，即刻返回。
 *
 * The function returns the number of events processed. 
 * 函数的返回值为已处理事件的数量
 */
int aeProcessEvents(aeEventLoop *eventLoop, int flags)
{
    int processed = 0, numevents;

    /* Nothing to do? return ASAP */
    if (!(flags & AE_TIME_EVENTS) && !(flags & AE_FILE_EVENTS)) return 0;

    /* Note that we want call select() even if there are no
     * file events to process as long as we want to process time
     * events, in order to sleep until the next time event is ready
     * to fire. */
    if (eventLoop->maxfd != -1 ||
        ((flags & AE_TIME_EVENTS) && !(flags & AE_DONT_WAIT))) {
        int j;
        aeTimeEvent *shortest = NULL;
        struct timeval tv, *tvp;

        // 获取最近的时间事件
        if (flags & AE_TIME_EVENTS && !(flags & AE_DONT_WAIT))
        	//这里使用链表存储时间事件，因此需要全部遍历出来对比找到时间最近的事件，时间复杂度是O(n)
            shortest = aeSearchNearestTimer(eventLoop);
        if (shortest) {
            // 如果时间事件存在的话
            // 那么根据最近可执行时间事件和现在时间的时间差来决定文件事件的阻塞时间
            long now_sec, now_ms;

            /* Calculate the time missing for the nearest
             * timer to fire. */
            // 计算距今最近的时间事件还要多久才能达到
            // 并将该时间距保存在 tv 结构中
            aeGetTime(&now_sec, &now_ms);
            tvp = &tv;
            tvp->tv_sec = shortest->when_sec - now_sec;
            if (shortest->when_ms < now_ms) {
                tvp->tv_usec = ((shortest->when_ms+1000) - now_ms)*1000;
                tvp->tv_sec --;
            } else {
                tvp->tv_usec = (shortest->when_ms - now_ms)*1000;
            }

            // 时间差小于 0 ，说明事件已经可以执行了，将秒和毫秒设为 0 （不阻塞）
            if (tvp->tv_sec < 0) tvp->tv_sec = 0;
            if (tvp->tv_usec < 0) tvp->tv_usec = 0;
        } else {
            
            // 执行到这一步，说明没有时间事件
            // 那么根据 AE_DONT_WAIT 是否设置来决定是否阻塞，以及阻塞的时间长度

            /* If we have to check for events but need to return
             * ASAP because of AE_DONT_WAIT we need to set the timeout
             * to zero */
            if (flags & AE_DONT_WAIT) {
                // 设置文件事件不阻塞
                tv.tv_sec = tv.tv_usec = 0;
                tvp = &tv;
            } else {
                /* Otherwise we can block */
                // 文件事件可以阻塞直到有事件到达为止
                tvp = NULL; /* wait forever */
            }
        }

        // 处理文件事件，阻塞时间由 tvp 决定
        numevents = aeApiPoll(eventLoop, tvp);
        for (j = 0; j < numevents; j++) {
            // 从已就绪数组中获取事件
            aeFileEvent *fe = &eventLoop->events[eventLoop->fired[j].fd];

            int mask = eventLoop->fired[j].mask;
            int fd = eventLoop->fired[j].fd;
            int rfired = 0;

           /* note the fe->mask & mask & ... code: maybe an already processed
             * event removed an element that fired and we still didn't
             * processed, so we check if the event is still valid. */
            // 读事件
            if (fe->mask & mask & AE_READABLE) {
                // rfired 确保读/写事件只能执行其中一个
                rfired = 1;
                fe->rfileProc(eventLoop,fd,fe->clientData,mask);
            }
            // 写事件
            if (fe->mask & mask & AE_WRITABLE) {
                if (!rfired || fe->wfileProc != fe->rfileProc)
                    fe->wfileProc(eventLoop,fd,fe->clientData,mask);
            }

            processed++;
        }
    }

    /* Check time events */
    // 执行时间事件
    if (flags & AE_TIME_EVENTS)
        processed += processTimeEvents(eventLoop);

    return processed; /* return the number of processed file/time events */
}

aeApiPoll()事件获取函数

这里接触到的是epoll、select，我们例举这两个简单说明下调用逻辑，关于epoll、select的OS底层实现以后开章节再深度剖析，这里是看Redis的多路复用模型即可。

epoll实现

如下是ae_epoll.c中aeApiPoll实现

/*
 * 获取可执行事件
 */
static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {
    aeApiState *state = eventLoop->apidata;
    int retval, numevents = 0;

    // 等待时间
    retval = epoll_wait(state->epfd,state->events,eventLoop->setsize,
            tvp ? (tvp->tv_sec*1000 + tvp->tv_usec/1000) : -1);

    // 有至少一个事件就绪？
    if (retval > 0) {
        int j;

        // 为已就绪事件设置相应的模式
        // 并加入到 eventLoop 的 fired 数组中
        numevents = retval;
        for (j = 0; j < numevents; j++) {
            int mask = 0;
            struct epoll_event *e = state->events+j;

            if (e->events & EPOLLIN) mask |= AE_READABLE;
            if (e->events & EPOLLOUT) mask |= AE_WRITABLE;
            if (e->events & EPOLLERR) mask |= AE_WRITABLE;
            if (e->events & EPOLLHUP) mask |= AE_WRITABLE;

            eventLoop->fired[j].fd = e->data.fd;
            eventLoop->fired[j].mask = mask;
        }
    }
    
    // 返回已就绪事件个数
    return numevents;
}

函数方法 int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

  • epfd 是epoll的描述符。

  • events 是分配好的epoll_event结构体数组，epoll将会把发生的事件复制到events数组

  • maxevents 表示本次可以返回的最大事件数目，通常maxevents参数与预分配的events数组的大小是相等的。

  • timeout 表示在没有检测到事件发生时最多等待的时间（单位为毫秒）

    • timeout = null，即不传入时间结构，就是将epoll置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止
    • timeout = 0，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值
    • timeout > 0，这就是等待的超时时间，即epoll在timeout时间内阻塞，超时时间之内有事件到来就返回，超时返回0

select实现

如下是ae_select.c中aeApiPoll实现

static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {
    aeApiState *state = eventLoop->apidata;
    int retval, j, numevents = 0;

    memcpy(&state->_rfds,&state->rfds,sizeof(fd_set));
    memcpy(&state->_wfds,&state->wfds,sizeof(fd_set));

    retval = select(eventLoop->maxfd+1,
                &state->_rfds,&state->_wfds,NULL,tvp);
    if (retval > 0) {
        for (j = 0; j <= eventLoop->maxfd; j++) {
            int mask = 0;
            aeFileEvent *fe = &eventLoop->events[j];

            if (fe->mask == AE_NONE) continue;
            if (fe->mask & AE_READABLE && FD_ISSET(j,&state->_rfds))
                mask |= AE_READABLE;
            if (fe->mask & AE_WRITABLE && FD_ISSET(j,&state->_wfds))
                mask |= AE_WRITABLE;
            eventLoop->fired[numevents].fd = j;
            eventLoop->fired[numevents].mask = mask;
            numevents++;
        }
    }
    return numevents;
}

函数方法int select(int maxfdp1, fd_set *readset, fd_set *writeset, struct timeval *timeout);

  • maxfdp1 是一个整数值，是指集合中所有文件描述符的范围，即所有文件描述符的最大值加1，不能错。Redis在select()函数中传入了maxfd+1。
  • readset 是指向fd_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的读变化的，即我们关心是否可以从这些文件中读取数据了，如果这个集合中有一个文件可读，select就会返回一个大于0的值，表示有文件可读；如果没有可读的文件，则根据timeout参数再判断是否超时，若超出timeout的时间，select返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的读变化
  • writeset 类似readset，这里是写变化
  • timeout
    • timeout = null，即不传入时间结构，就是将select置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止
    • timeout = 0，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值
    • timeout > 0，这就是等待的超时时间，即 select在timeout时间内阻塞，超时时间之内有事件到来就返回，超时返回0

对比

事件函数OS支持文件描述符数量限制时间复杂度
epollLinux-O(1)
evportSolaris-O(1)
kqueueOS X，FreeBSD-O(1)
select大部分操作系统都支持1024（32位）
2048（64位）
（内核参数FD_SETSIZE控制）		O(n)

事件驱动模型

在这里插入图片描述

参考

《Redis设计与实现》
https://github.com/huangz1990/redis-3.0-annotated
https://zhuanlan.zhihu.com/p/92739237
https://www.cnblogs.com/xuewangkai/p/11158576.html epoll
https://blog.csdn.net/lingfengtengfei/article/details/12392449 select

大摩羯先生
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Redis中事件驱动模型示例详解
01-19
Redis 是一个事件驱动的内存数据库，服务器需要处理两种类型的事件。 文件事件 时间事件 下面就会介绍这两种事件的实现原理。 文件事件 Redis 服务器通过 socket 实现与客户端（或其他redis服务器）的交互,文件...
REdis命令处理流程处理分析
一见
04-01 1234
分析版本：REdis-5.0.4。 REdis命令处理流程可分解成三个独立的流程（不包括复制和持久化）： 1)接受连接请求流程； 2)接收请求数据和处理请求流程，在这个过程并不会发送处理结果给Client，而只是将结果数据写入响应缓冲，将由响应请求流程来发送； 3)响应请求流程。 上述三个流程均是异步化的，并且没有直接的联系。它们的共同点均是通过REdis的简单事...
Redis 中的事件循环
程序猿开发日志【学习永无止境】
12-28 2823
在目前的很多服务中，由于需要持续接受客户端或者用户的输入，所以需要一个事件循环来等待并处理外部事件，这篇文章主要会介绍 Redis 中的事件循环是如何处理事件的。 在文章中，我们会先从 Redis 的实现中分析事件是如何被处理的，然后用更具象化的方式了解服务中的不同模块是如何交流的。 aeEventLoop 在分析具体代码之前，先了解一下在事件处理中处于核心部分的 aeEvent
redis03 补充 redis驱动模型：事件驱动
最新发布
qq_38757863的博客
06-09 167
1.文件系统。
Redis中的Reactor 模型的工作机制
Lee notes
03-28 1627
Redis中的Reactor 模型的工作机制 好，首先，我们来看看什么是 Reactor 模型。实际上，Reactor 模型就是网络服务器端用来处理高并发网络 IO 请求的一种编程模型。我把这个模型的特征用两个“三”来总结，也就是： 三类处理事件，即连接事件、写事件、读事件； 三个关键角色，即 reactor、acceptor、handler。 那么，Reactor 模型是如何基于这三类事件和三个角色来处理高并发请求的呢？下面我们就来具体了解下。 事件类型与关键角色 我们先来看看这三类事件和 React
Redis 多线程网络模型全面揭秘
hebtu666
02-21 3759
导语一文带你完全吃透 Redis 整个核心网络模型的原理和源码。 目录 导言 Redis 有多快？ Redis 为什么快？ Redis 为何选择单线程？ 避免过多的上下文切换开销 避免同步机制的开销 简单可维护 Redis 真的是单线程？ 单线程事件循环 多线程异步任务 Redis 多线程网络模型 设计思路 源码剖析 性能提升 模型缺陷 总结 博客原文 导言 在目前的技术选型中，Redis 俨然已经成为了系统高性能缓存方案的事实标准，因此现在 Redis...
一篇带你彻底搞明白Redis事件驱动
wdj_yyds的博客
06-19 554
Redis 通过 IO 多路复用技术，使用单线程就可以获取很高的并发访问。同时通过事件循环，将对应的功能都分散到不同的函数中，实现了高内聚。
仿redis事件驱动程序
06-11
仿redis事件驱动程序,是C语言写的，适用于linux下，直接编译就可以使用，自己测试过。主要是模仿redis的事件驱动，对于想学习redis源码的人，这个很有参考价值。此模型也可以直接拿到你的项目中使用。
提取redis事件机制源码为我所用
09-06
这种非阻塞的事件驱动方式使得Redis可以在单线程下处理大量并发连接。 2. **事件API** 在源码中，Redis的事件API主要包括`aeCreateEvent`、`aeDeleteEvent`、`aeProcessEvents`和`aeWait`等函数。这些函数用于创建...
redis异步事件说明11
08-08
Redis 是一个高性能的键值数据库，它通过使用事件驱动模型来处理并发请求，这使得 Redis 能够高效地处理大量操作。在这个模型中，异步事件处理是关键的一部分，特别是对于高并发场景，能有效避免阻塞，提高系统吞吐...
Redis学习之事件驱动模型
我家有猫已长成的博客
03-28 1194
Redis学习之事件驱动模型。
Redis(九）--Redis事件机制详解
m0_52675592的博客
05-16 275
文章目录事件驱动机制文件事件时间事件aeEventLoop（事件管理器）的具体实现创建文件事件事件处理删除事件 事件驱动机制 Redis采用事件驱动机制来处理大量的网络IO，Redis中的事件驱动库只关注网络IO以及定时器。 事件库处理两类事件： 文件事件：用于处理Redis服务器和客户端之间的网络IO. 事件事件：Redis服务器中的一些操作需要在给定的时间点执行，而时间事件就是处理这类定时操作的。 事件驱动库的代码主要是在src/ae.c中实现的，示意图如下： 文件事件 Redis基于Rea
Redis源码分析（二十）--- ae事件驱动
走在前往架构师的路上
10-26 8110
事件驱动这个名词出现的越来越频繁了，听起来非常高大上，今天本人把Redis内部的驱动模型研究了一番，感觉收获颇丰啊。一个ae.c主程序，加上4个事件类型的文件，让你彻底弄清楚，Redis是如何处理这些事件的。在Redis的事件处理中，用到了epoll，select，kqueue和evport，evport可能大家会陌生许多。前面3个都是非常常见的事件，在libevent的事件网络库中也都有出现。作
Redis2.2.2源码学习——aeEvent事件轮询
ordeder的专栏
10-16 5461
Version Redis2.2.2 Redis的事件主要分为文件事件和定时器时间，作者对这两种事件处理的高端之处在于预先计算最近一个要超时的定时器距离当前的事件间隔，在这个时间间隔内调用poll函数处理文件事件，之后再处理定时器时间。 /* File event structure */ typedef struct aeFileEvent { int mask; ///* 文件事件类型 读/写 one of AE_(READABLE|WRITABLE) */ aeFilePro
Redis源码阅读之: 事件模型ae
shuoGG的专栏
05-05 349
源码文件 src/ae.c 入口函数 src/ae.c下的void aeMain(aeEventLoop *eventLoop)函数; 推荐从这个函数开始阅读 /* * 事件处理器的主循环 */ void aeMain(aeEventLoop *eventLoop) { eventLoop->stop = 0; while (!eventLoop->stop...
redis源码分析之ae_epoll.c
小羽毛的博客
01-24 402
#include &lt;sys/epoll.h&gt; typedef struct aeApiState { //epoll 监听fd int epfd; //epoll wait产生的事件列表 struct epoll_event *events; } aeApiState; /** * 创建epoll * @param eventLoop * @r...
redis的ae事件模型
noob_zln的博客
03-30 1120
事件循环的数据结构aeEventLoop typedef struct aeEventLoop { int maxfd; /* 当前注册的最大文件描述符 */ int setsize; /* 允许的最大文件描述符 */ long long timeEventNextId; time_t lastTime; /* Used to detect sy...
Redis源码剖析和注释（十九）--- Redis 事件处理实现
热门推荐
men_wen的博客
05-10 2万+
Redis 事件处理实现1. Redis事件介绍Redis服务器是一个事件驱动程序。下面先来简单介绍什么是事件驱动。所谓事件驱动，就是当你输入一条命令并且按下回车，然后消息被组装成Redis协议的格式发送给Redis服务器，这就会产生一个事件，Redis服务器会接收该命令，处理该命令和发送回复，而当你没有与服务器进行交互时，那么服务器就会处于阻塞等待状态，会让出CPU从而进入睡眠状态，当事件触发时，
Redis核心技术-线程模型
ALONG的博客
12-19 970
  我们通常说，Redis 是单线程，主要是指 Redis 的网络 IO 和键值对读写是由一个线程来完成的，这也是 Redis 对外提供键值存储服务的主要流程。   但 Redis 的其他功能，比如持久化、异步删除、集群数据同步等，其实是由额外的线程执行的。 为什么使用单线程？   多线程并发开销大，访问共享资源时，要确保资源的正确性，需要额外的机制保证正确性，额外的操作增加了系统开销。 多线程为什么快呢？ 1.Redis基于内存存储和操作数据；
Redis 的io模型是事件驱动模型吗
05-14
是的，Redis使用事件驱动模型作为其I/O模型。Redis使用单线程事件循环模型来实现高性能和可伸缩性。在这个模型中，Redis使用一个事件处理器(event loop)来监听和处理I/O事件，当有新的客户端请求到达时，事件处理器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大摩羯先生

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

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

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

打赏作者

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

抵扣说明：

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

余额充值