深入分析Memcached的线程接入模型---下

最新推荐文章于 2024-09-17 11:14:07 发布
最新推荐文章于 2024-09-17 11:14:07 发布
阅读量610 收藏 1
点赞数
分类专栏： Linux 文章标签： memcached thread buffer initialization struct null

view plaincopy to clipboardprint?
/* 
 * Processes an incoming "handle a new connection" item. This is called when 
 * input arrives on the libevent wakeup pipe. 
 */ 
static void thread_libevent_process(int fd, short which, void *arg) {  
    LIBEVENT_THREAD *me = arg;  
    CQ_ITEM *item;  
    char buf[1];  
 
    //fd是该worker_thread的读管道的描述符，必须先从管道中读取一个字节出来，在水平触发模式下必须处理该事件，否则会被循环通知直到事件被处理。  
    if (read(fd, buf, 1) != 1)  
        if (settings.verbose > 0)  
            fprintf(stderr, "Can't read from libevent pipe/n");  
 
    //从该线程的连接队列获取一个item  
    item = cq_pop(me->new_conn_queue);  
 
    if (NULL != item) {  
 
       //处理对应的连接  
    conn *c = conn_new(item->sfd, item->init_state, item->event_flags,  
                           item->read_buffer_size, item->transport, me->base);  
          
        if (c == NULL) {  
              
            if (IS_UDP(item->transport)) {  
                fprintf(stderr, "Can't listen for events on UDP socket/n");  
                exit(1);  
                  
            } else {  
              
                if (settings.verbose > 0) {  
                    fprintf(stderr, "Can't listen for events on fd %d/n",  
                        item->sfd);  
                }  
                  
                close(item->sfd);  
            }  
              
              
        } else {  
          
            c->thread = me;    
              
        }  
 
     //该连接处理完毕后，放回cqi_freelist 链表     
        cqi_free(item);  
          
    }  
      
} 
/*
 * Processes an incoming "handle a new connection" item. This is called when
 * input arrives on the libevent wakeup pipe.
 */
static void thread_libevent_process(int fd, short which, void *arg) {
    LIBEVENT_THREAD *me = arg;
    CQ_ITEM *item;
    char buf[1];

    //fd是该worker_thread的读管道的描述符，必须先从管道中读取一个字节出来，在水平触发模式下必须处理该事件，否则会被循环通知直到事件被处理。
    if (read(fd, buf, 1) != 1)
        if (settings.verbose > 0)
            fprintf(stderr, "Can't read from libevent pipe/n");

    //从该线程的连接队列获取一个item
    item = cq_pop(me->new_conn_queue);

    if (NULL != item) {

       //处理对应的连接
 conn *c = conn_new(item->sfd, item->init_state, item->event_flags,
                           item->read_buffer_size, item->transport, me->base);
  
        if (c == NULL) {
   
            if (IS_UDP(item->transport)) {
                fprintf(stderr, "Can't listen for events on UDP socket/n");
                exit(1);
    
            } else {
           
                if (settings.verbose > 0) {
                    fprintf(stderr, "Can't listen for events on fd %d/n",
                        item->sfd);
                }
    
                close(item->sfd);
            }
   
   
        } else {
       
            c->thread = me; 
   
        }

  //该连接处理完毕后，放回cqi_freelist 链表 
        cqi_free(item);
  
    }
 
}

 

八，worker_libevent函数的分析

        worker_libevent函数就是每个worker_thread启动的执行体，每个worker_thread创建和初始化完毕后，就执行该函数。


view plaincopy to clipboardprint?
/* 
 * Worker thread: main event loop, workerx thread 的执行体 
 */ 
static void *worker_libevent(void *arg) {  
    LIBEVENT_THREAD *me = arg;  
 
    /* Any per-thread setup can happen here; thread_init() will block until 
     * all threads have finished initializing. 
     */ 
    pthread_mutex_lock(&init_lock);  
    init_count++;  
    pthread_cond_signal(&init_cond);  
    pthread_mutex_unlock(&init_lock);  
 
    //worker thread 进入libevent base loop 循环（重要的一步），等待事件的触发进行事件的处理  
    event_base_loop(me->base, 0);  
 
    return NULL;  
} 
/*
 * Worker thread: main event loop, workerx thread 的执行体
 */
static void *worker_libevent(void *arg) {
    LIBEVENT_THREAD *me = arg;

    /* Any per-thread setup can happen here; thread_init() will block until
     * all threads have finished initializing.
     */
    pthread_mutex_lock(&init_lock);
    init_count++;
    pthread_cond_signal(&init_cond);
    pthread_mutex_unlock(&init_lock);

    //worker thread 进入libevent base loop 循环（重要的一步），等待事件的触发进行事件的处理
    event_base_loop(me->base, 0);

    return NULL;
}
 

 

九，conn_new函数的分析（worker_thread的重要处理逻辑）


    核心的方法: 每个worker 线程收到pipe可读会调用该方法进行处理， 其基本逻辑是：首先从该线程的CQ队列中取队列头的一个CQ_ITEM,这个CQ_ITEM是被主线程丢到这个队列里的，item->sfd是已经建立的连接 的描述符，通过conn_new函数为该描述符注册libevent的读事件，me->base是代表自己的一个线程结构体，就是说对该描述符的事件处理交给当前这个workers线程处理, conn_new方法的最重要的内容如下代码所示：


view plaincopy to clipboardprint?
conn *conn_new(const int sfd,   
                enum conn_states init_state,  
                const int event_flags,  
                const int read_buffer_size,   
                enum network_transport transport,  
                struct event_base *base  
                )   
 {  
    conn *c = conn_from_freelist();  
    。。。//这里设置这个链接对象的值  
     
    //核心注册事件，注册sokect 的操作处理事件和对于的处理函数-event_handler  
    event_set(&c->event, sfd, event_flags, event_handler, (void *)c);  
    event_base_set(base, &c->event);  
    c->ev_flags = event_flags;  
 
    if (event_add(&c->event, 0) == -1) {  
        if (conn_add_to_freelist(c)) {  
            conn_free(c);  
        }  
        perror("event_add");  
        return NULL;  
    }  
    …  
    return c;  
} 
conn *conn_new(const int sfd,
                enum conn_states init_state,
                const int event_flags,
                const int read_buffer_size,
                enum network_transport transport,
                struct event_base *base
                )
 {
    conn *c = conn_from_freelist();
    。。。//这里设置这个链接对象的值
  
    //核心注册事件，注册sokect 的操作处理事件和对于的处理函数-event_handler
    event_set(&c->event, sfd, event_flags, event_handler, (void *)c);
    event_base_set(base, &c->event);
    c->ev_flags = event_flags;

    if (event_add(&c->event, 0) == -1) {
        if (conn_add_to_freelist(c)) {
            conn_free(c);
        }
        perror("event_add");
        return NULL;
    }
    …
    return c;
}
 


     可以看到新的连接被注册了一个事件（实际是EV_READ|EV_PERSIST）,由当前线程处理（因为这里的event_base是该workers线程自己的），当该连接有可读数据时会回调event_handler函数，实际上event_handler里主要是调用memcached的核心方法drive_machine，最后看看memcached网络事件处理的最核心部分- drive_machine 。需要铭记于心的是drive_machine是多线程环境执行的，主线程和workers都会执行drive_machine 。

 

十，drive_machine函数的分析


       drive_machine主要是通过当前连接的state来判断该进行何种处理，因为通过libevent注册了读写时间后回调的都是这个核心函数，所以实际上我们在注册libevent相应事件时，会同时把事件状态写到该conn结构体里，libevent进行回调时会把该conn结构作为参数传递过来，就是该方法的形参 。

view plaincopy to clipboardprint?
//真正处理跟已经连接的socket的逻辑  
static void drive_machine(conn *c) {  
    bool stop = false;  
    int sfd, flags = 1;  
    socklen_t addrlen;  
    struct sockaddr_storage addr;  
    int nreqs = settings.reqs_per_event;  
    int res;  
 
    assert(c != NULL);  
    while (!stop) {  
        switch(c->state) {  
 
        case conn_listening:  
            addrlen = sizeof(addr);           
         //处理accept出错的情况  
            if ((sfd = accept(c->sfd, (struct sockaddr *)&addr, &addrlen)) == -1) {  
                if (errno == EAGAIN || errno == EWOULDBLOCK) {  
                    /* these are transient, so don't log anything */ 
                    stop = true;  
                } else if (errno == EMFILE) {  
                    if (settings.verbose > 0)  
                        fprintf(stderr, "Too many open connections/n");  
                    accept_new_conns(false);  
                    stop = true;  
                } else {  
                    perror("accept()");  
                    stop = true;  
                }  
                break;  
            }  
 
         //设置sfd 为 非阻塞方式      
            if ((flags = fcntl(sfd, F_GETFL, 0)) < 0 ||  
                fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) {  
                perror("setting O_NONBLOCK");  
                close(sfd);  
                break;  
            }  
            //分发到某个指定的线程去  
            dispatch_conn_new(sfd, conn_new_cmd, EV_READ | EV_PERSIST,  
                                     DATA_BUFFER_SIZE, tcp_transport);  
            stop = true;  
            break;  
          
      // 以下代码略  
    }  
    return;  
} 
//真正处理跟已经连接的socket的逻辑
static void drive_machine(conn *c) {
    bool stop = false;
    int sfd, flags = 1;
    socklen_t addrlen;
    struct sockaddr_storage addr;
    int nreqs = settings.reqs_per_event;
    int res;

    assert(c != NULL);
    while (!stop) {
        switch(c->state) {

        case conn_listening:
            addrlen = sizeof(addr);   
      //处理accept出错的情况
            if ((sfd = accept(c->sfd, (struct sockaddr *)&addr, &addrlen)) == -1) {
                if (errno == EAGAIN || errno == EWOULDBLOCK) {
                    /* these are transient, so don't log anything */
                    stop = true;
                } else if (errno == EMFILE) {
                    if (settings.verbose > 0)
                        fprintf(stderr, "Too many open connections/n");
                    accept_new_conns(false);
                    stop = true;
                } else {
                    perror("accept()");
                    stop = true;
                }
                break;
            }

      //设置sfd 为 非阻塞方式 
            if ((flags = fcntl(sfd, F_GETFL, 0)) < 0 ||
                fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) {
                perror("setting O_NONBLOCK");
                close(sfd);
                break;
            }
            //分发到某个指定的线程去
            dispatch_conn_new(sfd, conn_new_cmd, EV_READ | EV_PERSIST,
                                     DATA_BUFFER_SIZE, tcp_transport);
            stop = true;
            break;
       
      // 以下代码略
    }
    return;
}
 


十一，主线程是如何进行dispatch的?

view plaincopy to clipboardprint?
/* 
 * Dispatches a new connection to another thread. This is only ever called 
 * from the main thread, either during initialization (for UDP) or because 
 * of an incoming connection. 
 */ 
void dispatch_conn_new(int sfd, enum conn_states init_state,  int event_flags, int read_buffer_size,   
                                              enum network_transport transport  
                                              )   
 {  
 
    //从cqi_freelist  或者malloc 一个CQ_ITEM  
    CQ_ITEM *item = cqi_new();  
      
    //round robin 一个worker 线程  
    int tid = (last_thread + 1) % settings.num_threads;  
 
    LIBEVENT_THREAD *thread = threads + tid;  
 
    //该次选中的worker 线程保留起来  
    last_thread = tid;  
 
    //fill 该CQ_ITEM 的内容  
    item->sfd = sfd;  
    item->init_state = init_state;  
    item->event_flags = event_flags;  
    item->read_buffer_size = read_buffer_size;  
    item->transport = transport;  
 
    //push 到选中的那个线程的连接队列里面  
    cq_push(thread->new_conn_queue, item);  
 
    MEMCACHED_CONN_DISPATCH(sfd, thread->thread_id);  
    //往对应的线程写pipe写一个空的字节，此时触发该线程的notify  
    //管道可读，并触发对应的事件处理流程  
    if (write(thread->notify_send_fd, "", 1) != 1) {  
        perror("Writing to thread notify pipe");  
    }  
} 
/*
 * Dispatches a new connection to another thread. This is only ever called
 * from the main thread, either during initialization (for UDP) or because
 * of an incoming connection.
 */
void dispatch_conn_new(int sfd, enum conn_states init_state,  int event_flags, int read_buffer_size,
                                              enum network_transport transport
                                              )
 {

    //从cqi_freelist  或者malloc 一个CQ_ITEM
    CQ_ITEM *item = cqi_new();
 
    //round robin 一个worker 线程
    int tid = (last_thread + 1) % settings.num_threads;

    LIBEVENT_THREAD *thread = threads + tid;

    //该次选中的worker 线程保留起来
    last_thread = tid;

    //fill 该CQ_ITEM 的内容
    item->sfd = sfd;
    item->init_state = init_state;
    item->event_flags = event_flags;
    item->read_buffer_size = read_buffer_size;
    item->transport = transport;

    //push 到选中的那个线程的连接队列里面
    cq_push(thread->new_conn_queue, item);

    MEMCACHED_CONN_DISPATCH(sfd, thread->thread_id);
    //往对应的线程写pipe写一个空的字节，此时触发该线程的notify
    //管道可读，并触发对应的事件处理流程
    if (write(thread->notify_send_fd, "", 1) != 1) {
        perror("Writing to thread notify pipe");
    }
}
 

 

可以清楚的看到，主线程首先创建了一个新的CQ_ITEM，然后通过round robin策略选择了一个thread
并通过cq_push将这个CQ_ITEM放入了该线程的CQ队列里，那么对应的workers线程是怎么知道的呢

就是通过这个
write(threads[thread].notify_send_fd, "", 1）
向该线程管道写了1字节数据，则该线程的libevent立即回调了thread_libevent_process方法（上面已经描述过）

然后那个线程取出item,注册读时间，当该条连接上有数据时，最终也会回调drive_machine方法，也就是
drive_machine方法的 case conn_read:等全部是workers处理的，主线程只处理conn_listening 建立连接这个

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/tenfyguo/archive/2010/01/31/5274435.aspx

鱼翅1013
关注
专栏目录
Redis——Redis线程模型原理
庄小焱
12-30 1254
Redis 作为缓存系统的事实标准，它的底层原理值得开发者去深入学习，Redis 自 2009 年发布第一版之后，其单线程网络模型的选择在社区中从未停止过讨论。如今到网络上搜索redis线程模型原理文章。都存在很多的误导大家的学习，同时没有深入对redis的线程模型的原理和redis到底使用的是单线程还是使用的多线的原因解释不清楚，今天博文博文将详细的介绍redis3.5的单线模型和redis6.0的多线程模型的原理。
深入分析Memcached的线程接入模型---上
梦里花
06-19 713
memcached是一个分布式的内存cache系统，目前被大量地运用于各种各样的站点中，以不断提高站点的总体访问性能，而另外一方面，memcached的使用是非常简单的，可以说，使用门槛很低，这也许是造成memcached目前非常流行的原因之一。我们可以看到，网上分析memcached的文章也比较多，本文是笔者结合memcached源代码的基础上对其线程接入模型进行深入的分析，通过学习和借鉴memcached设计和实现上 的一些思想，为我们的系统架构设计增添新的思路。简单的说，memcached的实现并没有
深入分析Memcached的线程接入模型---中
tenfyguo的技术专栏
01-31 3275
三，在main()函数中，初始化main_thread的event_base实例，见memcached.c//定义main_thread的event_base实例static struct event_base *main_base;//下面代码略…/* initialize main thread libevent instance , 初始化事件API */ma
memcached源码阅读----使用libevent和多线程模型
benpaobagzb的博客
06-12 1803
一、libevent的使用     首先我们知道，memcached是使用了iblievet作为网络框架的，而iblievet又是单线程模型的基于linux下epoll事件的异步模型。因此，其基本的思想就是 对可读，可写，超时，出错等事件进行绑定函数，等有其事件发生，对其绑定函数回调。      可以减掉了解一下 libevent基本api调用 [cpp] 
Redis - 多线程网络模型全面揭秘
Pastxu的小屋
04-23 267
导言 在目前的技术选型中，Redis 俨然已经成为了系统高性能缓存方案的事实标准，因此现在 Redis 也成为了后端开发的基本技能树之一，Redis 的底层原理也顺理成章地成为了必须学习的知识。 Redis 从本质上来讲是一个网络服务器，而对于一个网络服务器来说，网络模型是它的精华，搞懂了一个网络服务器的网络模型，你也就搞懂了它的本质。 本文通过层层递进的方式，介绍了 Redis 网络模型的版本变更历程，剖析了其从单线程进化到多线程的工作原理，此外，还一并分析并解答了 Redis 的网络模型的很多抉择
云原生与12要素(Cloud-Native & 12-Factor)
白石的专栏
09-14 817
**云原生本质上不是部署，而是以什么方式来构建应用**，云原生的最终目的是为了提高开发效率，提升业务敏捷度、扩容性、可用性、资源利用率，降低成本。 12-Factor 可以适用于任意语言和后端服务（数据库、消息队列、缓存等）开发的应用程序，自然也适用于云原生。在构建云原生应用时，也需要考虑这十二个方面的内容。
Redis多线程网络模型全面分析
j简说Linux的博客
11-17 229
Redis 的作者 antirez 为了解决这个问题进行了很多思考，一开始他想的办法是一种渐进式的方案：利用定时器和数据游标，每次只删除一小部分的数据，比如 1000 个对象，最终清除掉所有的数据，但是这种方案有个致命的缺陷，如果同时还有其他客户端往某个正在被渐进式删除的 key 里继续写入数据，而且删除的速度跟不上写入的数据，那么将会无止境地消耗内存，虽然后来通过一个巧妙的办法解决了，但是这种实现使 Redis 变得更加复杂，而多线程看起来似乎是一个水到渠成的解决方案：简单、易理解。
Redis 多线程网络模型全面揭秘
Linuxhus的博客
09-05 244
Redis 作为缓存系统的事实标准，它的底层原理值得开发者去深入学习，Redis 自 2009 年发布第一版之后，其单线程网络模型的选择在社区中从未停止过讨论，多年来一直有呼声希望 Redis 能引入多线程从而利用多核优势，但是作者 antirez 是一个追求大道至简的开发者，对 Redis 加入任何新功能都异常谨慎，所以在 Redis 初版发布的十年后才最终将 Redis 的核心网络模型改造成多线程模式，这期间甚至诞生了一些 Redis 多线程的替代项目。
技术选型系列 -- Redis VS Memcached
a934079371的博客
03-14 485
经平台同意授权转载作者：田京昆（腾讯后台研发工程师）来源：腾云阁（https://www.qcloud.com/community/article/12...
人工智能大模型技术基础系列之：分布式模型存储与加载
程序员光剑
11-01 253
随着人工智能技术的快速发展，大规模语言模型（Large Language Models, LLMs）如GPT-3、BERT、T5等在自然语言处理领域取得了突破性进展。这些模型通常包含数十亿甚至上千亿个参数，为了有效地存储、加载和推理如此庞大的模型，分布式技术成为了不可或缺的解决方案。本文将深入探讨大模型分布式存储与加载的核心技术，包括模型并行、张量并行、流水线并行等关键概念，以及它们在实际应用中的实现方法和优化策略。
图解Redis 01 | 初识Redis
大厂小码农的博客
09-17 1042
Redis 是一种基于内存的数据库，所有的数据读写操作都在内存中完成，因此读写速度非常快。它被广泛应用于缓存、消息队列、分布式锁等场景。Redis 提供了多种数据类型来支持不同的业务需求，如 String、Hash、List、Set、Zset、Bitmaps、HyperLogLog、GEO、Stream 等。Redis 对这些数据类型的操作都是原子的——因为Redis是单线程架构，一条命令的执行是由单个线程完成，不会出现并发竞争的问题。
12306抢票脚本 - Bypass
最新发布
09-17
12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306
单片机与蓝牙模块的无线通信项目实战.md
09-17
如何使用单片机与蓝牙模块（如HC-05/HC-06）实现无线通信的详细步骤。首先，介绍了蓝牙模块的基本工作原理、引脚功能及配置方法。接着，讲解了硬件设计，包括单片机与蓝牙模块的连接、按键与LED模块的接线。然后，详细描述了软件设计，包括串口通信的初始化、蓝牙模块的数据接收与处理。项目调试部分涉及蓝牙连接的测试、串口通信的验证及功能调试，确保系统稳定运行。最后，探讨了项目的扩展可能性，如双向通信、多个设备通信及低功耗设计。这些内容为构建一个基于单片机和蓝牙的无线通信系统提供了全面的指导。
计算机科学中的基数排序算法原理与实现
09-17
本文详细介绍了基数排序这一非比较型排序方法的算法原理以及其在实际应用中如何操作。从初始化桶到最后重构阵列的每一步均进行了阐述，并提供了基于Python的实现例子。另外，对基数排序的时间和空间复杂度给出了深入解析及其使用情境说明，有助于了解排序机制并正确评估算法性能优劣。 适合人群：具备基本算法基础的数据科学家，研究和开发人员。 使用场景及目标：帮助理解和学习基数排序的技术要点和内在逻辑，掌握其实现在固定长度整数集合上进行快速排序的操作技巧。 其它提示：尽管该排序方法在特定条件下效率显著高于比较式方法，但须谨慎应用于数据种类变化多样的环境中。
Python100道题(100).zip
09-17
基数排序
基于大语言模型的智能体架构设计模式
09-17
本文档提出了一套由18种架构设计模式组成的设计模式目录，旨在指导从事基础模型（FM）驱动的人工智能（GenAI）开发的研究者与实践者们有效地克服现有挑战。它涵盖了被动目标创建者、主动目标创建者以及投票合作等多角度的解决方案，并详细讨论了每个设计模式的具体应用背景与解决相关问题的能力，从而支持基于FM的技术创新和发展，为实现自主型任务导向智能体提供坚实的理论基础和技术支持。适用于所有对智能体开发感兴趣的人群。 适合人群：具有一定编程基础且关注于智能体系统开发的研究员、软件设计师及开发者。 使用场景及目标：帮助相关人员深入理解当前先进基于基础模型的智能体发展趋势，在实际项目实践中更好地应对智能体的目标制定与行为规划方面的各种复杂情况。 额外说明：本研究不仅限于具体的技术实现细节，更多地强调从高层次视角探索设计思路和策略，促进跨学科协作及知识积累共享。
Memcached线程模型解析：主线程与工作线程交互
这种线程模型允许Memcached在多核环境下并行处理客户端请求，提高了服务的响应速度和吞吐量。同时，通过主线程与工作线程的协作，避免了主线程被长时间阻塞，确保了服务器的高可用性。通过libevent这一事件驱动库，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值