转载:http://blog.csdn.net/luotuo44/article/details/42963793
温馨提示:本文用到了一些可以在启动memcached设置的全局变量。关于这些全局变量的含义可以参考《memcached启动参数详解》。对于这些全局变量,处理方式就像《如何阅读memcached源代码》所说的那样直接取其默认值。另外, 本文会提及LRU队列,关于LRU队列的介绍可以参考《LRU队列与item结构体》。
过期失效处理:
一个item在两种情况下会过期失效:1.item的exptime时间戳到了。2.用户使用flush_all命令将全部item变成过期失效的。读者可能会说touch命令也可以使得一个item过期失效,其实这也属于前面说的第一种情况。
超时失效:
对于第一种过期失效,memcached的使用懒惰处理:不主动检测一个item是否过期失效。当worker线程访问这个item时,才检测这个item的exptime时间戳是否到了。比较简单,这里就先不贴代码,后面会贴。
flush_all命令:
第二种过期失效是用户flush_all命令设置的。flush_all会将所有item都变成过期失效。所有item是指哪些item?因为多个客户端会不断地往memcached插入item,所以必须要明白所有item是指哪些。是以worker线程接收到这个命令那一刻为界?还是以删除那一刻为界?
当worker线程接收到flush_all命令后,会用全局变量settings的oldest_live成员存储接收到这个命令那一刻的时间(准确地说,是worker线程解析得知这是一个flush_all命令那一刻再减一),代码为settings.oldest_live =current_time - 1;然后调用item_flush_expired函数锁上cache_lock,然后调用do_item_flush_expired函数完成工作。
- void do_item_flush_expired(void) {
- int i;
- item *iter, *next;
- if (settings.oldest_live == 0)
- return;
- for (i = 0; i < LARGEST_ID; i++) {
- for (iter = heads[i]; iter != NULL; iter = next) {
- if (iter->time != 0 && iter->time >= settings.oldest_live) {
- next = iter->next;
- if ((iter->it_flags & ITEM_SLABBED) == 0) {
- do_item_unlink_nolock(iter, hash(ITEM_key(iter), iter->nkey));
- }
- } else {
-
- break;
- }
- }
- }
- }
do_item_flush_expired函数内部会遍历所有LRU队列,检测每一个item的time成员。检测time成员是合理的。如果time成员小于settings.oldest_live就说明该item在worker线程接收到flush_all命令的时候就已经存在了(time成员表示该item的最后一次访问时间)。那么就该删除这个item。
这样看来memcached是以worker线程接收到flush_all命令那一刻为界的。等等等等,看清楚一点!!在do_item_flush_expired函数里面,不是当item的time成员小于settings.oldest_live时删除这个item,而是大于的时候才删除。从time成员变量的意义来说,大于代表什么啊?有大于的吗?奇怪!@#@&¥
实际上memcached是以删除那一刻为界的。那settings.oldest_live为什么要存储worker线程接收到flush_all命令的时间戳?为什么又要判断iter->time是否大于settings.oldest_live呢?
按照一般的做法,在do_item_flush_expired函数中直接把哈希表和LRU上的所有item统统删除即可。这样确实是可以达到目标。但在本worker线程处理期间,其他worker线程完全不能工作(因为do_item_flush_expired的调用者已经锁上了cache_lock)。而LRU队列里面可能有大量的数据,这个过期处理过程可能会很长。其他worker线程完全不能工作是难于接受的。
memcached的作者肯定也意识到这个问题,所以他就写了一个奇怪的do_item_flush_expired函数,用来加速。do_item_flush_expired只会删除少量特殊的item。如何特殊法,在后面代码注释中会解释。对于其他大量的item,memcached采用懒惰方式处理。只有当worker线程试图访问该item,才检测item是否已经被设置为过期的了。事实上,无需对item进行任何设置就能检测该item是否为过期的,通过settings.oldest_live变量即可。这种懒惰和前面第一种item过期失效的处理是一样的。
现在再看一下do_item_flush_expired函数,看一下特殊的item。
- void do_item_flush_expired(void) {
- int i;
- item *iter, *next;
- if (settings.oldest_live == 0)
- return;
- for (i = 0; i < LARGEST_ID; i++) {
- for (iter = heads[i]; iter != NULL; iter = next) {
-
-
-
-
-
-
-
- if (iter->time != 0 && iter->time >= settings.oldest_live) {
- next = iter->next;
- if ((iter->it_flags & ITEM_SLABBED) == 0) {
-
-
- do_item_unlink_nolock(iter, hash(ITEM_key(iter), iter->nkey));
- }
- } else {
-
-
- break;
- }
- }
- }
- }
懒惰删除:
现在阅读item的懒惰删除。注意代码中的注释。
- item *do_item_get(const char *key, const size_t nkey, const uint32_t hv) {
- item *it = assoc_find(key, nkey, hv);
- ...
-
- if (it != NULL) {
-
-
-
-
-
-
-
- if (settings.oldest_live != 0 && settings.oldest_live <= current_time &&
- it->time <= settings.oldest_live) {
- do_item_unlink(it, hv);
- do_item_remove(it);
- it = NULL;
-
- } else if (it->exptime != 0 && it->exptime <= current_time) {
- do_item_unlink(it, hv);
- do_item_remove(it);
- it = NULL;
-
- } else {
- it->it_flags |= ITEM_FETCHED;
- }
- }
-
-
- return it;
- }
可以看到,在查找到一个item后就要检测它是否过期失效了。失效了就要删除之。
除了do_item_get函数外,do_item_alloc函数也是会处理过期失效item的。do_item_alloc函数不是删除这个过期失效item,而是占为己用。因为这个函数的功能是申请一个item,如果一个item过期了那么就直接霸占这个item的那块内存。下面看一下代码。
- item *do_item_alloc(char *key, const size_t nkey, const int flags,
- const rel_time_t exptime, const int nbytes,
- const uint32_t cur_hv) {
- uint8_t nsuffix;
- item *it = NULL;
- char suffix[40];
-
- size_t ntotal = item_make_header(nkey + 1, flags, nbytes, suffix, &nsuffix);
- if (settings.use_cas) {
- ntotal += sizeof(uint64_t);
- }
-
-
- unsigned int id = slabs_clsid(ntotal);
-
-
- int tries = 5;
- item *search;
- item *next_it;
- rel_time_t oldest_live = settings.oldest_live;
-
- search = tails[id];
- for (; tries > 0 && search != NULL; tries--, search=next_it) {
- next_it = search->prev;
- ...
-
- if (refcount_incr(&search->refcount) != 2) {
-
- do_item_update_nolock(search);
- tries++;
- refcount_decr(&search->refcount);
-
-
- continue;
- }
-
-
-
-
-
-
-
- if ((search->exptime != 0 && search->exptime < current_time)
- || (search->time <= oldest_live && oldest_live <= current_time)) {
-
- it = search;
-
-
- slabs_adjust_mem_requested(it->slabs_clsid, ITEM_ntotal(it), ntotal);
- do_item_unlink_nolock(it, hv);
-
- it->slabs_clsid = 0;
- }
-
-
-
-
- refcount_decr(&search->refcount);
- break;
- }
-
- ...
- return it;
- }
-
-
-
- void slabs_adjust_mem_requested(unsigned int id, size_t old, size_t ntotal)
- {
- pthread_mutex_lock(&slabs_lock);
- slabclass_t *p;
- if (id < POWER_SMALLEST || id > power_largest) {
- fprintf(stderr, "Internal error! Invalid slab class\n");
- abort();
- }
-
- p = &slabclass[id];
-
- p->requested = p->requested - old + ntotal;
- pthread_mutex_unlock(&slabs_lock);
- }
flush_all命令是可以有时间参数的。这个时间和其他时间一样取值范围是 1到REALTIME_MAXDELTA(30天)。如果命令为flush_all 100,那么99秒后所有的item失效。此时settings.oldest_live的值为current_time+100-1,do_item_flush_expired函数也没有什么用了(总不会被抢占CPU99秒吧)。也正是这个原因,需要在do_item_get里面,加入settings.oldest_live<= current_time这个判断,防止过早删除了item。
这里明显有一个bug。假如客户端A向服务器提交了flush_all10命令。过了5秒后,客户端B向服务器提交命令flush_all100。那么客户端A的命令将失效,没有起到任何作用。
LRU爬虫:
前面说到,memcached是懒惰删除过期失效item的。所以即使用户在客户端使用了flush_all命令使得全部item都过期失效了,但这些item还是占据者哈希表和LRU队列并没有归还给slab分配器。
LRU爬虫线程:
有没有办法强制清除这些过期失效的item,不再占据哈希表和LRU队列的空间并归还给slabs呢?当然是有的。memcached提供了LRU爬虫可以实现这个功能。
要使用LRU爬虫就必须在客户端使用lru_crawler命令。memcached服务器根据具体的命令参数进行处理。
memcached是用一个专门的线程负责清除这些过期失效item的,本文将称这个线程为LRU爬虫线程。默认情况下memcached是不启动这个线程的,但可以在启动memcached的时候添加参数-o lru_crawler启动这个线程。也可以通过客户端命令启动。即使启动了这个LRU爬虫线程,该线程还是不会工作。需要另外发送命令,指明要对哪个LRU队列进行清除处理。现在看一下lru_crawler有哪些参数。
LRU爬虫命令:
- lru_crawler <enable|disable> 启动或者停止一个LRU爬虫线程。任何时刻,最多只有一个LRU爬虫线程。该命令对settings.lru_crawler进行赋值为true或者false
- lru_crawler crawl <classid,classid,classid|all> 可以使用2,3,6这样的列表指明要对哪个LRU队列进行清除处理。也可以使用all对所有的LRU队列进行处理
- lru_crawler sleep <microseconds> LRU爬虫线程在清除item的时候会占用锁,会妨碍worker线程的正常业务。所以LRU爬虫在处理的时候需要时不时休眠一下。默认休眠时间为100微秒。该命令对settings.lru_crawler_sleep进行赋值
- lru_crawler tocrawl <32u> 一个LRU队列可能会有很多过期失效的item。如果一直检查和清除下去,势必会妨碍worker线程的正常业务。这个参数用来指明最多只检查每一条LRU队列的多少个item。默认值为0,所以如果不指定那么就不会工作。该命令对settings.lru_crawler_tocrawl进行赋值
如果要启动LRU爬虫主动删除过期的item,需要这样做:首先使用lru_crawler enable命令启动一个LRU爬虫线程。然后使用lru_crawler tocrawl num命令确定每一个LRU队列最多检查num-1个item。最后使用命令lru_crawler crawl <classid,classid,classid|all> 指定要处理的LRU队列。lru_crawler sleep可以不设置,如果要设置那么可以在lru_crawler crawl命令之前设置即可。
启动LRU爬虫线程:
现在来看一下LRU爬虫是怎么工作的。先来看一下memcached为LRU爬虫定义了哪些全局变量。
- static volatile int do_run_lru_crawler_thread = 0;
- static int lru_crawler_initialized = 0;
- static pthread_mutex_t lru_crawler_lock = PTHREAD_MUTEX_INITIALIZER;
- static pthread_cond_t lru_crawler_cond = PTHREAD_COND_INITIALIZER;
-
-
- int init_lru_crawler(void) {
- if (lru_crawler_initialized == 0) {
- if (pthread_cond_init(&lru_crawler_cond, NULL) != 0) {
- fprintf(stderr, "Can't initialize lru crawler condition\n");
- return -1;
- }
- pthread_mutex_init(&lru_crawler_lock, NULL);
- lru_crawler_initialized = 1;
- }
- return 0;
- }
代码比较简单,这里就不说了。下面看一下lru_crawler enable和disable命令。enable命令会启动一个LRU爬虫线程,而disable会停止这个LRU爬虫线程,当然不是直接调用pthread_exit停止线程。pthread_exit函数是一个危险函数,不应该在代码出现。
- static pthread_t item_crawler_tid;
-
-
-
- int start_item_crawler_thread(void) {
- int ret;
-
-
-
-
- if (settings.lru_crawler)
- return -1;
-
- pthread_mutex_lock(&lru_crawler_lock);
- do_run_lru_crawler_thread = 1;
- settings.lru_crawler = true;
-
-
-
- if ((ret = pthread_create(&item_crawler_tid, NULL,
- item_crawler_thread, NULL)) != 0) {
- fprintf(stderr, "Can't create LRU crawler thread: %s\n",
- strerror(ret));
- pthread_mutex_unlock(&lru_crawler_lock);
- return -1;
- }
- pthread_mutex_unlock(&lru_crawler_lock);
-
- return 0;
- }
-
-
-
- int stop_item_crawler_thread(void) {
- int ret;
- pthread_mutex_lock(&lru_crawler_lock);
- do_run_lru_crawler_thread = 0;
-
- pthread_cond_signal(&lru_crawler_cond);
- pthread_mutex_unlock(&lru_crawler_lock);
- if ((ret = pthread_join(item_crawler_tid, NULL)) != 0) {
- fprintf(stderr, "Failed to stop LRU crawler thread: %s\n", strerror(ret));
- return -1;
- }
- settings.lru_crawler = false;
- return 0;
- }
可以看到worker线程在接收到” lru_crawler enable”命令后会启动一个LRU爬虫线程。这个LRU爬虫线程还没去执行任务,因为还没有指定任务。命令"lru_crawler tocrawl num"并不是启动一个任务。对于这个命令,worker线程只是简单地把settings.lru_crawler_tocrawl赋值为num。
清除失效item:
命令”lru_crawler crawl<classid,classid,classid|all>”才是指定任务的。该命令指明了要对哪个LRU队列进行清理。如果使用all那么就是对所有的LRU队列进行清理。
在看memcached的清理代码之前,先考虑一个问题:怎么对一条LRU队列进行清理?
最直观的做法是先加锁(锁上cache_lock),然后遍历一整条LRU队列。直接判断LRU队列里面的每一个item即可。明显这种方法有问题。如果memcached有大量的item,那么遍历一个LRU队列耗时将太久。这样会妨碍worker线程的正常业务。当然我们可以考虑使用分而治之的方法,每次只处理几个item,多次进行,最终达到处理整个LRU队列的目标。但LRU队列是一个链表,不支持随机访问。处理队列中间的某个item,需要从链表头或者尾依次访问,时间复杂度还是O(n)。
伪item:
memcached为了实现随机访问,使用了一个很巧妙的方法。它在LRU队列尾部插入一个伪item,然后驱动这个伪item向队列头部前进,每次前进一位。
这个伪item是全局变量,LRU爬虫线程无须从LRU队列头部或者尾部遍历就可以直接访问这个伪item。通过这个伪item的next和prev指针,就可以访问真正的item。于是,LRU爬虫线程无需遍历就可以直接访问LRU队列中间的某一个item。
下面看一下lru_crawler_crawl函数,memcached会在这个函数会把伪item插入到LRU队列尾部的。当worker线程接收到lru_crawler crawl<classid,classid,classid|all>命令时就会调用这个函数。因为用户可能要求LRU爬虫线程清理多个LRU队列的过期失效item,所以需要一个伪item数组。伪item数组的大小等于LRU队列的个数,它们是一一对应的。
-
- typedef struct {
- struct _stritem *next;
- struct _stritem *prev;
- struct _stritem *h_next;
- rel_time_t time;
- rel_time_t exptime;
- int nbytes;
- unsigned short refcount;
- uint8_t nsuffix;
- uint8_t it_flags;
- uint8_t slabs_clsid;
- uint8_t nkey;
- uint32_t remaining;
- } crawler;
-
-
-
- static crawler crawlers[LARGEST_ID];
- static int crawler_count = 0;
-
-
-
-
- enum crawler_result_type lru_crawler_crawl(char *slabs) {
- char *b = NULL;
- uint32_t sid = 0;
- uint8_t tocrawl[POWER_LARGEST];
-
-
-
-
- if (pthread_mutex_trylock(&lru_crawler_lock) != 0) {
- return CRAWLER_RUNNING;
- }
- pthread_mutex_lock(&cache_lock);
-
-
-
- if (strcmp(slabs, "all") == 0) {
- for (sid = 0; sid < LARGEST_ID; sid++) {
- tocrawl[sid] = 1;
- }
- } else {
- for (char *p = strtok_r(slabs, ",", &b);
- p != NULL;
- p = strtok_r(NULL, ",", &b)) {
-
-
- if (!safe_strtoul(p, &sid) || sid < POWER_SMALLEST
- || sid > POWER_LARGEST) {
- pthread_mutex_unlock(&cache_lock);
- pthread_mutex_unlock(&lru_crawler_lock);
- return CRAWLER_BADCLASS;
- }
- tocrawl[sid] = 1;
- }
- }
-
-
-
- for (sid = 0; sid < LARGEST_ID; sid++) {
- if (tocrawl[sid] != 0 && tails[sid] != NULL) {
-
-
- crawlers[sid].nbytes = 0;
- crawlers[sid].nkey = 0;
- crawlers[sid].it_flags = 1;
- crawlers[sid].next = 0;
- crawlers[sid].prev = 0;
- crawlers[sid].time = 0;
- crawlers[sid].remaining = settings.lru_crawler_tocrawl;
- crawlers[sid].slabs_clsid = sid;
-
- crawler_link_q((item *)&crawlers[sid]);
- crawler_count++;
- }
- }
- pthread_mutex_unlock(&cache_lock);
-
- pthread_cond_signal(&lru_crawler_cond);
- STATS_LOCK();
- stats.lru_crawler_running = true;
- STATS_UNLOCK();
- pthread_mutex_unlock(&lru_crawler_lock);
- return CRAWLER_OK;
- }
现在再来看一下伪item是怎么在LRU队列中前进的。先看一个伪item前进图。
从上面的图可以看到,伪item通过与前驱节点交换位置实现前进。如果伪item是LRU队列的头节点,那么就将这个伪item移出LRU队列。函数crawler_crawl_q完成这个交换操作,并且返回交换前伪item的前驱节点(当然在交换后就变成伪item的后驱节点了)。如果伪item处于LRU队列的头部,那么就返回NULL(此时没有前驱节点了)。crawler_crawl_q函数里面那些指针满天飞,这里就不贴出代码了。
上面的图,虽然伪item遍历了LRU队列,但并没有删除某个item。这样画,一来是为了好看,二来遍历LRU队列不一定会删除item的(item不过期失效就不会删除)。
清理item:
前面说到,可以用命令lru_crawler tocrawl num指定每个LRU队列最多只检查num-1个item。看清楚点,是检查数,不是删除数,而且是num-1个。首先要调用item_crawler_evaluate函数检查一个item是否过期,是的话就删除。如果检查完num-1个,伪item都还没有到达LRU队列的头部,那么就直接将这个伪item从LRU队列中删除。下面看一下item_crawler_thread函数吧。
- static void *item_crawler_thread(void *arg) {
- int i;
-
- pthread_mutex_lock(&lru_crawler_lock);
- while (do_run_lru_crawler_thread) {
-
- pthread_cond_wait(&lru_crawler_cond, &lru_crawler_lock);
-
- while (crawler_count) {
- item *search = NULL;
- void *hold_lock = NULL;
-
- for (i = 0; i < LARGEST_ID; i++) {
- if (crawlers[i].it_flags != 1) {
- continue;
- }
- pthread_mutex_lock(&cache_lock);
-
- search = crawler_crawl_q((item *)&crawlers[i]);
- if (search == NULL ||
-
-
- (crawlers[i].remaining && --crawlers[i].remaining < 1)) {
-
-
- crawlers[i].it_flags = 0;
- crawler_count--;
- crawler_unlink_q((item *)&crawlers[i]);
- pthread_mutex_unlock(&cache_lock);
- continue;
- }
- uint32_t hv = hash(ITEM_key(search), search->nkey);
-
- if ((hold_lock = item_trylock(hv)) == NULL) {
- pthread_mutex_unlock(&cache_lock);
- continue;
- }
-
-
-
- if (refcount_incr(&search->refcount) != 2) {
- refcount_decr(&search->refcount);
- if (hold_lock)
- item_trylock_unlock(hold_lock);
- pthread_mutex_unlock(&cache_lock);
- continue;
- }
-
-
- item_crawler_evaluate(search, hv, i);
-
- if (hold_lock)
- item_trylock_unlock(hold_lock);
- pthread_mutex_unlock(&cache_lock);
-
-
-
- if (settings.lru_crawler_sleep)
- usleep(settings.lru_crawler_sleep);
- }
- }
- STATS_LOCK();
- stats.lru_crawler_running = false;
- STATS_UNLOCK();
- }
- pthread_mutex_unlock(&lru_crawler_lock);
-
- return NULL;
- }
-
-
-
- static void item_crawler_evaluate(item *search, uint32_t hv, int i) {
- rel_time_t oldest_live = settings.oldest_live;
-
-
- if ((search->exptime != 0 && search->exptime < current_time)
-
- || (search->time <= oldest_live && oldest_live <= current_time)) {
- itemstats[i].crawler_reclaimed++;
-
- if ((search->it_flags & ITEM_FETCHED) == 0) {
- itemstats[i].expired_unfetched++;
- }
-
-
- do_item_unlink_nolock(search, hv);
- do_item_remove(search);
- assert(search->slabs_clsid == 0);
- } else {
- refcount_decr(&search->refcount);
- }
- }
真正的LRU淘汰:
虽然本文前面多次使用LRU这个词,并且memcached代码里面的函数命名也用了lru前缀,特别是lru_crawler命令。但实际上这和LRU淘汰没有半毛钱关系!!
上当受骗了吧,骂吧:¥&@#¥&*@%##……%#%……#¥%¥@#%……
读者可以回忆一下操作系统里面的LRU算法。本文里面删除的那些item都是过期失效的,删除了活该。过期了还霸着位置,有点像霸着茅坑不拉屎。操作系统里面LRU算法是因为资源不够,迫于无奈而被踢的,被踢者也是挺无奈的。不一样吧,所以说本文前面说的不是LRU。
那memcached的LRU在哪里体现了呢?do_item_alloc函数!!前面的博文一直都有提到这个神一般的函数,但从没有给出完整的版本。当然这里也不会给出完整的版本。因为这个函数里面还是有一些东西暂时无法解释给读者们听。现在估计读者都能体会到《
如何阅读memcached源码
》中写到的:memcached模块间的关联性太多了。
- item *do_item_alloc(char *key, const size_t nkey, const int flags,
- const rel_time_t exptime, const int nbytes,
- const uint32_t cur_hv) {
- uint8_t nsuffix;
- item *it = NULL;
- char suffix[40];
-
- size_t ntotal = item_make_header(nkey + 1, flags, nbytes, suffix, &nsuffix);
- if (settings.use_cas) {
- ntotal += sizeof(uint64_t);
- }
-
-
- unsigned int id = slabs_clsid(ntotal);
-
- int tries = 5;
- item *search;
- item *next_it;
- rel_time_t oldest_live = settings.oldest_live;
- search = tails[id];
-
- for (; tries > 0 && search != NULL; tries--, search=next_it) {
- next_it = search->prev;
-
- uint32_t hv = hash(ITEM_key(search), search->nkey);
-
-
- if (refcount_incr(&search->refcount) != 2) {
- refcount_decr(&search->refcount);
- continue;
- }
-
-
-
-
-
-
-
- if ((search->exptime != 0 && search->exptime < current_time)
- || (search->time <= oldest_live && oldest_live <= current_time)) {
-
- ..
- } else if ((it = slabs_alloc(ntotal, id)) == NULL) {
-
-
-
- if (settings.evict_to_free == 0) {
-
- itemstats[id].outofmemory++;
- } else {
-
-
- it = search;
-
-
- slabs_adjust_mem_requested(it->slabs_clsid, ITEM_ntotal(it), ntotal);
- do_item_unlink_nolock(it, hv);
-
- it->slabs_clsid = 0;
-
- }
- }
-
-
-
- refcount_decr(&search->refcount);
- break;
- }
-
- ...
-
- return it;
- }