memcached线程模型

来源：互联网发布：阿里云专有网络收费编辑：程序博客网时间：2024/06/14 18:04

1.main函数中调用thread_init()，初始化setting.num_threads个worker线程以及一个主线程dispatcher_thread。
每个worker线程用pipe创建一个管道，并注册libevent事件，当管道的读端可以读时，就调用thread_libevent_process()函数。
thread_libevent_process()做的事情等下再说。

[cpp] view plaincopy
void thread_init(int nthreads, struct event_base *main_base) {  
    threads = calloc(nthreads, sizeof(LIBEVENT_THREAD));  
      
    //初始化dispatcher线程  
    dispatcher_thread.base = main_base;  
    dispatcher_thread.thread_id = pthread_self();  
      
    //初始化nthreads个worker线程  
    for (i = 0; i < nthreads; i++) {  
        int fds[2];  
        if (pipe(fds)) {  
            perror("Can't create notify pipe");  
            exit(1);  
        }  
  
        //每个线程打开一个管道  
        threads[i].notify_receive_fd = fds[0];  
        threads[i].notify_send_fd = fds[1];  
  
        //注册libevent事件。当该线程的管道的读端可以读时，调用thread_libevent_process()  
        setup_thread(&threads[i]);   
    }  
      
    /* Create threads after we've done all the libevent setup. */  
    /* 创建worker线程，并让每个线程进入event_base_loop()循环。 
       前面的threads数组只是创建了nthreads个LIBEVENT_THREAD对象， 
       并初始化了libevent以及其他信息。并没有真正开始一个新的进程。 
       在create_worker里才真正调用了pthread_create， 
       并且每个进程都进入了event_base_loop() 
    */  
    for (i = 0; i < nthreads; i++) {  
        create_worker(worker_libevent, &threads[i]);  
    }  
}  
  
static void setup_thread(LIBEVENT_THREAD *me) {  
    me->base = event_init();  
      
    /* Listen for notifications from other threads */  
    //当读端可以读时，调用thread_libevent_process()函数  
    event_set(&me->notify_event, me->notify_receive_fd,  
              EV_READ | EV_PERSIST, thread_libevent_process, me);  
    event_base_set(me->base, &me->notify_event);  
  
    if (event_add(&me->notify_event, 0) == -1) {  
        fprintf(stderr, "Can't monitor libevent notify pipe\n");  
        exit(1);  
    }  
      
    /*初始化每个线程的new_conn_queue成员。 
    new_conn_queue成员是一个conn_queue指针，相当于一个队列， 
    记录分配到该线程的，等待new一个conn对象的那些item的信息。 
    每次调用thread_libevent_process()时， 
    就从该队列中取出一个item，然后建立一个conn*/  
    me->new_conn_queue = malloc(sizeof(struct conn_queue));  
    cq_init(me->new_conn_queue);  
      
}  
  
static void create_worker(void *(*func)(void *), void *arg) {  
    pthread_t       thread;  
    pthread_attr_t  attr;  
    int             ret;  
  
    pthread_attr_init(&attr);  
  
    if ((ret = pthread_create(&thread, &attr, func, arg)) != 0) {  
        fprintf(stderr, "Can't create thread: %s\n",  
                strerror(ret));  
        exit(1);  
    }  
}  
  
static void *worker_libevent(void *arg) {  
    LIBEVENT_THREAD *me = arg;  
    event_base_loop(me->base, 0);  
    return NULL;  
}  

2.main函数中，然后调用server_sockets，在指定的端口和ip地址上分别建立tcp和udp的监听。

然后

1) 如果是TCP，就调用conn_new(sfd, conn_listening, EV_READ|EV+PERSIST, 1, tcp_transport, main_base)，该函数在main_base上建立libevent事件，当sfd可读时，调用event_handler(). 而event_handler()又调用drive_machine().

2) 如果是UDP，就调用dispatch_conn_new(sfd, conn_read, EV_READ | EV_PERSIST, UDP_READ_BUFFER_SIZE, udp_transport)，该函数用round-robin的方法找到一个worker线程，然后new一个CQ_ITEM对象，把该item对象放到worker线程的new_conn_queue队列中。然后，通知该worker线程。通知的方法是，往该线程的写端写一个字节，这样，该线程的读端就可读了。由于之前已经讲过，每个worker线程注册了libevent事件，当读端可读时，就调用thread_libevent_process()。
server_sockets()调用server_socket(), server_socket()先在指定端口和ip上建立socket，得到文件描述符sfd，然后bind，然后

[cpp] view plaincopy
static int server_socket(const char *interface,  
                         int port,  
                         enum network_transport transport,  
                         FILE *portnumber_file) {  
    if ((sfd = new_socket(next)) == -1) {  
        ...  
    }  
    if (bind(sfd, next->ai_addr, next->ai_addrlen) == -1) {  
        ...  
    }  
    if (!IS_UDP(transport) && listen(sfd, settings.backlog) == -1) {  
        ...  
    }  
      
    if (IS_UDP(transport)) {  
            int c;  
  
            for (c = 0; c < settings.num_threads_per_udp; c++) {  
                /* this is guaranteed to hit all threads because we round-robin */  
                dispatch_conn_new(sfd, conn_read, EV_READ | EV_PERSIST,  
                                  UDP_READ_BUFFER_SIZE, transport);  
            }  
        } else {  
            if (!(listen_conn_add = conn_new(sfd, conn_listening,  
                                             EV_READ | EV_PERSIST, 1,  
                                             transport, main_base))) {  
               ...  
            }  
        }     
}  

3. 继续2.1

如果是TCP，把conn的状态设为conn_listening, 设置libevent事件。当一个新的tcp connection到达时，进入drive_machine。

[cpp] view plaincopy
static void drive_machine(conn *c) {  
    switch(c->state) {  
        case conn_listening:  
            addrlen = sizeof(addr);  
            sfd = accept(c->sfd, (struct sockaddr *)&addr, &addrlen));  
            dispatch_conn_new(sfd, conn_new_cmd, EV_READ | EV_PERSIST,  
                                     DATA_BUFFER_SIZE, tcp_transport);  
                                      
    ...  
      
}  

调用dispatch_conn_new，把新的tcp connection的sfd指派到某个worker线程上。

4. 继续2.2

注意server_socket中，当协议是UDP时，调用dispatch_new_conn，但是是在一个for循环中。就是说，对于一个udp的描述符，指派了settings.num_threads_per_udp个线程来监控该udp描述符。

这叫做“惊群”。当一个udp连接到达时，所有的libevent都能检测到该事件，但是只有一个线程调用recvfrom能返回数据。其他线程都返回失败。

udp用惊群而tcp不用的原因可能是：对于tcp，主线程（即dispatch_thread）会一直监控是否有新的tcp connection到达。如果到达，就会指派一个worker thread处理它。而对于udp，如果不用惊群，那么只有一个worker 线程监控udp 请求。因此，当该线程在处理一个udp请求时，其他的udp请求就不能得到及时处理。

另一个原因是：

“TCP是定然不能这样设计的,所以只能accept之后分发到特定线程,因为是字节流.
而UDP是包,随便哪个线程处理包1,再换个线程处理包2也是没有问题的.”