memcached的执行流程

1、libevent的使用方法

初始化   struct event_base main_base = event_init();  //多孔插座

事件设置 event_set(&ev, listen_fd, EV_READ | EV_PERSIST, cb, *arg) //设置灯泡

                  event_base_set(main_base, &ev);//设置灯泡属于哪个插座

事件添加 event_add(&ev, NULL)  //插上电板

进入事件循环 event_base_loop(main_base, 0); //进入事件循环

 

struct event {  TAILQ_ENTRY (event) ev_next;  TAILQ_ENTRY (event) ev_active_next;  TAILQ_ENTRY (event) ev_signal_next;  unsigned int min_heap_idx; /* for managing timeouts */  struct event_base *ev_base;  int ev_fd;  short ev_events;  short ev_ncalls;  short *ev_pncalls; /* Allows deletes in callback */  struct timeval ev_timeout;  int ev_pri;  /* smaller numbers are higher priority */  void (*ev_callback)(int, short, void *arg);  void *ev_arg;  int ev_res;  /* result passed to event callback */  int ev_flags;  };    

 

ev_events：event关注的事件类型，它可以是以下3种类型：I/O事件： EV_WRITE和EV_READ；定时事件：EV_TIMEOUT；信号： EV_SIGNAL；辅助选项：EV_PERSIST，表明是一个永久事件。

#define EV_TIMEOUT 0x01   #define EV_READ  0x02   #define EV_WRITE 0x04   #define EV_SIGNAL 0x08   #define EV_PERSIST 0x10 /* Persistant event */

2、主程序详细流程

(1)初始化阶段

settings_init()初始化settings结构体。

static void settings_init(void) {    settings.use_cas = true;    settings.access = 0700;    settings.port = 11211;    settings.udpport = 11211;    /* By default this string should be NULL for getaddrinfo() */    settings.inter = NULL;    settings.maxbytes = 64 * 1024 * 1024; /* default is 64MB */    settings.maxconns = 1024;         /* to limit connections-related memory to about 5MB */    settings.verbose = 0;    settings.oldest_live = 0;    settings.evict_to_free = 1;       /* push old items out of cache when memory runs out */    settings.socketpath = NULL;       /* by default, not using a unix socket */    settings.factor = 1.25;    settings.chunk_size = 48;         /* space for a modest key and value */    settings.num_threads = 4;         /* N workers */    settings.num_threads_per_udp = 0;    settings.prefix_delimiter = ':';    settings.detail_enabled = 0;    settings.reqs_per_event = 20;    settings.backlog = 1024;    settings.binding_protocol = negotiating_prot;    settings.item_size_max = 1024 * 1024; /* The famous 1MB upper limit. */    settings.maxconns_fast = false;    settings.hashpower_init = 0;    settings.slab_reassign = false;    settings.slab_automove = 0;}

setbuf(stderr, NULL);设置stderr为无缓冲。

int getopt(int argc, char* const argv[ ], const char* optstring);获取参数用于设置settings结构体。

查看和设置资源限制（getrlimit(), setrlimit()），放弃root权利等。

event_init();

stats_init();初始化struct stats（global stats）。

assoc_init(settings.hashpower_init);->初始化primary_hashtable(Main hash table, 类型为static item**)。

conn_init();->初始化freeconns(Free list management for connections, 类型为static conn)为全0，初始化freecurr为0。

slabs_init(settings.maxbytes, settings.factor, preallocate);初始化slab class，详见数据结构一节。

 

(2)线程创建阶段

thread_init(settings.num_threads, main_base);

        初始化锁和条件变量，尤其是item_locks[ ]，初始化static LIBEVENT_THREAD *threads和static LIBEVENT_DISPATCHER_THREAD dispatcher_thread(即为主线程)，之后调用setup_thread(&threads[i])和create_worker()。其中setup_thread()设置事件处理函数thread_libevent_process，但尚未进入事件循环，也还没有创建线程；之后初始化new_conn_queue成员（queue of new connections to handle）；之后调用cache_create()初始化suffix_cache成员，创建了一个cache，name为“suffix”。create_worker(worker_libevent, &threads[i])创建4个线程，线程函数为worker_libevent()。worker_libevent()只是简单的进入事件循环。

        注意：利用条件变量使得，thread_init()会阻塞，直到所有线程都已创建完毕。

        关于其中的pthread_key_create()和pthread_setspecific()，可见http://blog.csdn.net/yangzhiloveyou/article/details/8043573.

/* * Initializes the thread subsystem, creating various worker threads. * * nthreads  Number of worker event handler threads to spawn * main_base Event base for main thread */void thread_init(int nthreads, struct event_base *main_base) {    int         i;    int         power;    pthread_mutex_init(&cache_lock, NULL);    pthread_mutex_init(&stats_lock, NULL);    pthread_mutex_init(&init_lock, NULL);    pthread_cond_init(&init_cond, NULL);    pthread_mutex_init(&cqi_freelist_lock, NULL);    cqi_freelist = NULL;    /* Want a wide lock table, but don't waste memory */    if (nthreads < 3) {        power = 10;    } else if (nthreads < 4) {        power = 11;    } else if (nthreads < 5) {        power = 12;    } else {        /* 8192 buckets, and central locks don't scale much past 5 threads */        power = 13;    }    item_lock_count = hashsize(power);    item_locks = calloc(item_lock_count, sizeof(pthread_mutex_t));    if (! item_locks) {        perror("Can't allocate item locks");        exit(1);    }    for (i = 0; i < item_lock_count; i++) {        pthread_mutex_init(&item_locks[i], NULL);    }    pthread_key_create(&item_lock_type_key, NULL);    //用于在线程间传递当前锁类型，全局锁还是细粒度锁    pthread_mutex_init(&item_global_lock, NULL);    threads = calloc(nthreads, sizeof(LIBEVENT_THREAD));    if (! threads) {        perror("Can't allocate thread descriptors");        exit(1);    }    dispatcher_thread.base = main_base;    dispatcher_thread.thread_id = pthread_self();    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];        setup_thread(&threads[i]);        /* Reserve three fds for the libevent base, and two for the pipe */        stats.reserved_fds += 5;    }    /* Create threads after we've done all the libevent setup. */    for (i = 0; i < nthreads; i++) {        create_worker(worker_libevent, &threads[i]);    }    /* Wait for all the threads to set themselves up before returning. */    pthread_mutex_lock(&init_lock);    wait_for_thread_registration(nthreads);    pthread_mutex_unlock(&init_lock);}

start_assoc_maintenance_thread() 创建线程maintenance_tid，线程函数为assoc_maintenance_thread()。

        assoc_maintenance_thread()在expanding（如何expanding暂不讨论）之后，调用switch_item_lock_type(ITEM_LOCK_GRANULAR)，使得所有线程开始使用细粒度锁（通过管道通知各线程，并阻塞等待各线程设置完毕）；之后调用slabs_rebalancer_resume()解锁slabs_rebalance_lock锁（什么时候上的锁？什么作用？）；最后调用pthread_cond_wait(&maintenance_cond, &cache_lock);阻塞，等待其他线程使用pthread_cond_signal()唤醒（注意pthread_cond_signal()不能在pthread_cond_wait()之前执行，否则唤醒信号丢失）。

如果settings.slab_reassign为true，调用start_slab_maintenance_thread()创建相关线程。此处为false，所以不调用，暂不讨论。

clock_handler(0, 0, 0);调用evtimer_add()添加计数器clockevent，定时一秒，处理函数为clock_handler()，即自身。可以看出clock_handler()的作用就是每一秒钟更新一次current_time。

 

(3)socket创建阶段

如果settings.socketpath != NULL，就调用server_socket_unix()创建Unix套接字；此处为NULL，不执行，暂不讨论。

server_sockets(settings.port, tcp_transport, portnumber_file)调用server_socket()。server_socket()中调用new_socket()创建socket，并设置为非阻塞模式；设置SO_REUSEADDR；对于TCP，设置SO_KEEPALIVE，SO_LINGER，TCP_NODELAY；对于TCP，调用conn_new()（对于UDP，调用dispatch_conn_new()）。
        conn_new()先调用conn_from_freelist()从freelist获得一个connection（此时freelist为空，所以返回NULL）；初始化一个struct conn；设置listen套接字sfd的事件处理函数为event_handler()；如果事件添加失败，则将已初始化好的conn加入freelist（conn_add_to_freelist()）。

        此处server_sockets()创建了两个监听端口，一个IPV4，一个IPV6，两个struct conn最终链入static conn* listen_conn链表。

        注意：在<netdb.h>中，#define NI_MAXSERV 32; #define NI_MAXHOST 1025。

        SO_REUSEADDR：允许重启的监听服务器bind其众所周知端口，即使以前建立的将该端口用作它们本地端口的连接仍存在。允许进程绑定一个处于TIME_WAIT的端口。

        SO_KEEPALIVE：如果两小时无数据交换，发送存活探测分节。

        SO_LINGER：设置close之后对缓冲区和套接口的处理；此处设置l_onff为0，即在套接口上不能再发出发送和接收请求，套接口发送缓冲区中内容被发送到对端。

        TCP_NODELAY：将数据包直接发送，而不是组成大的分组再发送。

 server_sockets(settings.udpport, udp_transport, portnumber_file)针对UDP，同样调用server_socket()。server_socket()中创建socket并调用maximize_sndbuf()设置发送缓存为最大值。之后bind()。最后调用dispatch_conn_new()。

         dispatch_conn_new()首先调用cqi_new()从cqi_freelist获得一个CQ_ITEM（struct conn_queue_item，An item in the connection queue），初始化CQ_ITEM；分配一个thread，调用cq_push(thread->new_conn_queue, item)将该item链入thread的conn_queue中；最后写一个‘c’到thread，这将使thread调用事件处理函数thread_libevent_process()，进一步调用conn_new(item->sfd, item->init_state, item->event_flags, item->read_buffer_size, item->transport, me->base))。可以看出，实际上主进程将item传送给thread，thread通过这个item来创建一个conn。

/* * 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) {    CQ_ITEM *item = cqi_new();    int tid = (last_thread + 1) % settings.num_threads;    //以此种方式来取出线程    LIBEVENT_THREAD *thread = threads + tid;    last_thread = tid;    item->sfd = sfd;    item->init_state = init_state;    item->event_flags = event_flags;    item->read_buffer_size = read_buffer_size;    item->transport = transport;    //将新item放至threads的new_conn_queue队列中    cq_push(thread->new_conn_queue, item);    MEMCACHED_CONN_DISPATCH(sfd, thread->thread_id);    //写一个字节启动新的线程    if (write(thread->notify_send_fd, "", 1) != 1) {        perror("Writing to thread notify pipe");    }}

        至此，创建了两个tcp socket（分别用于ipv4和ipv6），主进程创建conn并监听；主进程创建了两个udp socket（分别用于ipv4和ipv6），4个子进程创建conn并各自管理。如下：

<28 server listening (auto-negotiate)<29 server listening (auto-negotiate)<30 send buffer was 112640, now 268435456<30 server listening (udp)<30 server listening (udp)<30 server listening (udp)<30 server listening (udp)<31 send buffer was 112640, now 268435456<31 server listening (udp)<31 server listening (udp)<31 server listening (udp)<31 server listening (udp)

(5)最后阶段

event_base_loop(main_base, 0)主进程进入事件循环。

        小结一下：主线程中的事件主要是针对两个tcp socket的，事件处理函数为event_handler()；还有一个计数器事件clockevent，定时一秒，处理函数为clock_handler()。四个工作线程的事件一样，都是一个管道notify_receive_fd（事件处理函数为thread_libevent_process()），一个udp ipv4 socket，一个udp ipv6 socket，这两个的事件处理函数为event_handler() 。注意四个工作线程之前就进入事件循环了。

至此，程序就完全跑起来了。

 

(6)清理阶段

 默认情况下，event_base_loop()会一直循环，等待事件触发，然后调用他们的回调函数。直到没有添加的事件，或者调用了event_base_loopbreak()或者event_base_loopexit()。如果event_base_loop()退出，主进程将会执行一些清理过程，如下：

stop_assoc_maintenance_thread()简单的设置do_run_maintenance_thread = 0;线程maintenance_tid检测到do_run_maintenance_thread = 0就会自动退出。......

 

3、当client发起连接

执行命令telnet localhost 11211，向memcached发起tcp连接。memcached调用event_handler()处理。

        event_handler(const int fd, const short which, void *arg)其中which传入event.ev_events，为事件类型。event_handler()调用drive_machine(conn *c)。drive_machine()之后介绍。