memcached-version-1.4.25
介绍
memcache 中实现了内存管理模型用来存储数据，而在此基础上又实现了一套LRU爬虫模型来维护这些已使用的内存，因为如果一直使用这些内存而不去维护会占用大量的系统资源，所以提供这么一套机制来维护内存，目前有三条爬虫线程分别实现了维护item、维护slab区、维护LRU队列 等功能，由于这些爬虫线程是在内存模型基础上去实现的-Memcache-内存模型-源码分析-所以最好对内存模型有所了解.
LRU 爬虫线程介绍
<a href="#1F"> item 爬虫线程介绍 </a>
该爬虫线程的功能是自动删除过期的item，因为memcache默认是懒惰删除法，就是等客户端 get 这个 item 的时候去判断是否过期如果过期则删除但是如果客户端一直不去 get 这个 item，那么这个item就会一直占用资源不会被释放掉，所以本爬虫线程就是为了解决这个问题。<a href="#2F"> lru 爬虫线程介绍 </a>
每一个 slab[x] 对应三条队列，分别是HOT_LRU、WARM_LRU、COLD_LRU而该爬虫线程就是去不断调整这三条队列下的item链表，因为在获取一个item获取不到的时候，会去这三条队列下淘汰一个item来使用，所以需要不断的调整这三条队列，保证总被访问的item不被淘汰掉，不常访问或过期的item优先被淘汰.
<b>HOT_LRU：</b> 新获取的item会添加在HOT_LRU队列，如果访问HOT_LRU队尾的item则挪到HOT_LRU队头，超出HOT_LRU队列限额之后在挪到COLD_LRU队列.
<b>COLD_LRU：</b> 如果访问COLD_LRU队尾的item则挪到WARM_LRU队列。
<b>WARM_LRU：</b> 如果访问WARM_LRU队尾的item则挪到WARM_LRU队头，超出WARM_LRU队列限额之后在挪到COLD_LRU队列。<a href="#3F"> slab 爬虫线程介绍 </a>
内存初始化会把内存划分成 slab[1~63]->chunk_1[1M]->item 这种的形式，每个slab区域( slab[1]=80K、slab[2]=120k )存放不同大小的item，但如果一直使用 slab[1] 这个内存区域，就会不断去内存池申请chunk[1M]，直到把内存池全部申请完，这样导致的后果就是如果想要在使用 slab[2] 这个内存区域，就无法在去内存池申请chunk[1M]，也就是无法在存储120k大小的item，只能一直使用80k的item，而该爬虫线程的作用就是解决上述出现的问题，如果发现每个slab区域空闲的item数量加在一起大于2.5个chunk，每个chunk由若干个item组成，也就是相当于有大于2.5个chunk是空闲的，这样则回收一个chunk，把回收的这个chunk放到slab[0]这个区域，这样的话就解决了上述所出现的问题如果去内存池申请chunk失败，则从slab[0]区域获取一个刚才回收的chunk来使用，所以本线程最终的作用就是维护内存块的.
源码实现
在 Memcache 启动的时候可以通过参数来控制是否启动爬虫线程
int main(){
//省略...
//启动 item 爬虫线程
if (start_lru_crawler && start_item_crawler_thread() != 0) {
fprintf(stderr, "Failed to enable LRU crawler thread\n");
exit(EXIT_FAILURE);
}
//启动 lru 维护爬虫线程
if (start_lru_maintainer && start_lru_maintainer_thread() != 0) {
fprintf(stderr, "Failed to enable LRU maintainer thread\n");
return 1;
}
//启动 slab 维护爬虫线程
if (settings.slab_reassign &&
start_slab_maintenance_thread() == -1) {
exit(EXIT_FAILURE);
}
//省略...
}
start_item_crawler_thread() 启动item爬虫线程
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;
//启动线程, 但是不会马上运行, 会处于挂起状态, 等待触发信号(后面介绍).
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;
}
// 等待 item_crawler_thread 线程启动完毕之后在退出
pthread_cond_wait(&lru_crawler_cond, &lru_crawler_lock);
pthread_mutex_unlock(&lru_crawler_lock);
return 0;
}
start_slab_maintenance_thread() 启动slab维护爬虫线程
int start_slab_maintenance_thread(void) {
int ret;
slab_rebalance_signal = 0;
slab_rebal.slab_start = NULL;
//在上面介绍的时候说过,如果空闲item超过2.5个chunk则回收一个chunk
//在回收chunk的时候,会默认回收slab下第一个chunk,然后把该chunk下面
//的item一个一个挪到后面空闲的其他chunk空间,这个值就是控制一次循环
//最多移动多少个item,后面代码会有体现.
char *env = getenv("MEMCACHED_SLAB_BULK_CHECK");
if (env != NULL) {
slab_bulk_check = atoi(env);
if (slab_bulk_check == 0) {
slab_bulk_check = DEFAULT_SLAB_BULK_CHECK;
}
}
if (pthread_cond_init(&slab_rebalance_cond, NULL) != 0) {
fprintf(stderr, "Can't intiialize rebalance condition\n");
return -1;
}
pthread_mutex_init(&slabs_rebalance_lock, NULL);
//启动线程, 但是不会马上运行, 会处于挂起状态, 等待触发信号(后面介绍).
if ((ret = pthread_create(&rebalance_tid, NULL,
slab_rebalance_thread, NULL)) != 0) {
fprintf(stderr, "Can't create rebal thread: %s\n", strerror(ret));
return -1;
}
return 0;
}
start_lru_maintainer_thread() 启动lru维护爬虫线程
int start_lru_maintainer_thread(void) {
int ret;
pthread_mutex_lock(&lru_maintainer_lock);
//启动线程标识
do_run_lru_maintainer_thread = 1;
settings.lru_maintainer_thread = true;
//启动线程
if ((ret = pthread_create(&lru_maintainer_tid, NULL,
lru_maintainer_thread, NULL)) != 0) {
fprintf(stderr, "Can't create LRU maintainer thread: %s\n",
strerror(ret));
pthread_mutex_unlock(&lru_maintainer_lock);
return -1;
}
pthread_mutex_unlock(&lru_maintainer_lock);
return 0;
}
注意上面的代码在启动完线程之后并不会马上去运行，而是处于挂起状态，至于什么时候运行这些线程需要等待触发信号，而这个触发信号就是在lru维护线程函数里面去调用相关代码处理判断符合条件之后触发的，也就相当于通过lru维护线程函数统一去调度，看下面的代码.
lru_maintainer_thread() lru维护线程函数
static void *lru_maintainer_thread(void *arg) {
int i;
//每次循环执行之后延时时间
useconds_t to_sleep = MIN_LRU_MAINTAINER_SLEEP;
rel_time_t last_crawler_check = 0;
pthread_mutex_lock(&lru_maintainer_lock);
if (settings.verbose > 2)
fprintf(stderr, "Starting LRU maintainer background thread\n");
//死循环,不断循环执行
while (do_run_lru_maintainer_thread) {
int did_moves = 0;
pthread_mutex_unlock(&lru_maintainer_lock);
//每次while循环之后延迟执行时间
usleep(to_sleep);
pthread_mutex_lock(&lru_maintainer_lock);
STATS_LOCK();
stats.lru_maintainer_juggles++;
STATS_UNLOCK();
//搜索源代码发现lru_maintainer_check_clsid一直都等于0
//所以默认应该不会命中该if条件
if (lru_maintainer_check_clsid != 0) {
did_moves = lru_maintainer_juggle(lru_maintainer_check_clsid);
lru_maintainer_check_clsid = 0;
} else {
//循环获取 slab id 然后依次调用
for (i = POWER_SMALLEST; i < MAX_NUMBER_OF_SLAB_CLASSES; i++) {
did_moves += lru_maintainer_juggle(i);
}
}
//did_moves 等于本次循环所有 slab[1-63] 区共移除多少个 item
//然后根据移除数量确定下次while循环延迟执行时间
if (did_moves == 0) {
if (to_sleep < MAX_LRU_MAINTAINER_SLEEP)
to_sleep += 1000;
} else {
to_sleep /= 2;
if (to_sleep < MIN_LRU_MAINTAINER_SLEEP)
to_sleep = MIN_LRU_MAINTAINER_SLEEP;
}
//判断是否开启了item爬虫线程
if (settings.lru_crawler && last_crawler_check != current_time) {
//如果开启了则调用该函数执行,判断是否符合触发item爬虫线程条件
//如果符合条件则触发信号
lru_maintainer_crawler_check();
last_crawler_check = current_time;
}
}
pthread_mutex_unlock(&lru_maintainer_lock);
if (settings.verbose > 2)
fprintf(stderr, "LRU maintainer thread stopping\n");
return NULL;
}
lru_maintainer_juggle()
static int lru_maintainer_juggle(const int slabs_clsid) {
int i;
int did_moves = 0;
bool mem_limit_reached = false;
unsigned int total_chunks = 0;
unsigned int chunks_perslab = 0;
unsigned int chunks_free = 0;
// 获取 slabs_clsid 下有多少空闲的item
// chunks_free 空闲 item 数量
// total_chunks 总 item 数量(已使用+未使用)
// chunks_perslab 该 slabs_clsid 下的 chunk 最多能包含多少个 item
chunks_free = slabs_available_chunks(slabs_clsid, &mem_limit_reached,
&total_chunks, &chunks_perslab);
if (settings.expirezero_does_not_evict)
total_chunks -= noexp_lru_size(slabs_clsid);
//settings.slab_automove 默认等于0
//这里的chunks_free判断就是上面说的触发slab爬虫线程的关键
//当空闲的item大于2.5个chunk则执行回收流程,上面介绍过.
if (settings.slab_automove > 0 && chunks_free > (chunks_perslab * 2.5)) {
//调用该函数,触发信号,执行slab爬虫线程
slabs_reassign(slabs_clsid, SLAB_GLOBAL_PAGE_POOL);
}
//循环1000次调整该slabs_clsid下面的三条队列item
for (i = 0; i < 1000; i++) {
int do_more = 0;
if (lru_pull_tail(slabs_clsid, HOT_LRU, total_chunks, false, 0) ||
lru_pull_tail(slabs_clsid, WARM_LRU, total_chunks, false, 0)) {
do_more++;
}
do_more += lru_pull_tail(slabs_clsid, COLD_LRU, total_chunks, false, 0);
//如果一个item都没有被移除则跳出
if (do_more == 0)
break;
did_moves++;
}
return did_moves;
}
可以看到上面的代码已经体现出来了，lru维护爬虫线程函数先运行，然后统一去处理并调用相关的函数，最后触发对应的爬虫线程去执行.
<a id="1F"> item 爬虫线程，相关代码分析</a>
item爬虫
lru_maintainer_crawler_check()
static void lru_maintainer_crawler_check(void) {
int i;
//保存每个 slab_id 爬虫的开始状态
static rel_time_t last_crawls[MAX_NUMBER_OF_SLAB_CLASSES];
static rel_time_t next_crawl_wait[MAX_NUMBER_OF_SLAB_CLASSES];
//循环所有slab_id
for (i = POWER_SMALLEST; i < MAX_NUMBER_OF_SLAB_CLASSES; i++) {
//获取每个slab_id的爬虫状态
crawlerstats_t *s = &crawlerstats[i];
//如果该 slab_id 下爬虫状态等于0则代表该slab id下没有爬虫
//不等于0则代表有爬虫
if (last_crawls[i] == 0) {
//添加一个爬虫到该slab_id下的三条队列之前也说过,每个slab_id都有三条队列
//但是注意是开启lru模式才会有三条队列,不开启的话只有一条
if (lru_crawler_start(i, 0) > 0) {
//记录该slab_id爬虫的开始状态,就是当前时间而已
last_crawls[i] = current_time;
}
}
pthread_mutex_lock(&lru_crawler_stats_lock);
//如果该slab_id下的爬虫爬取完毕,会将s->run_complete设置为true
//而里面的代码就是确认该 slab id 是否可以重新再添加爬虫,因为在
//添加完爬虫的时候会更改爬虫状态last_crawls[i] = current_time
//如果想重新在添加爬虫需要在置为0。
//注意下:
//因为当前这是一个循环,所以在添加完第一个slab_id下的爬虫之后,去通知爬虫线程处理
//但是爬虫线程(有可能)并不会马上爬取完毕,所以这里的条件就不会马上为true,可能
//会等到下次lru维护线程在调用本函数,然后再循环到该slab_id下才会看到效果.
if (s->run_complete) {
int x;
//seen: 未过期的item数量
//noexp: 永不过期的item数量
uint64_t possible_reclaims = s->seen - s->noexp;
uint64_t available_reclaims = 0;
//计算未过期item的百分比
uint64_t low_watermark = (s->seen / 100) + 1;
//当前时间减去爬取结束时间,就是计算一下当前时间距离爬取结束时间相距多少秒
rel_time_t since_run = current_time - s->end_time;
/* Don't bother if the payoff is too low. */
if (settings.verbose > 1)
fprintf(stderr, "maint crawler: low_watermark: %llu, possible_reclaims: %llu, since_run: %u\n",
(unsigned long long)low_watermark, (unsigned long long)possible_reclaims,
(unsigned int)since_run);
for (x = 0; x < 60; x++) {
//(0 * 60) + 60 = 60
//(1 * 60) + 60 = 120
//(2 * 60) + 60 = 180
//相当于判断当前时间距离爬取结束时间是否大于60s、120s、180s、等
if (since_run < (x * 60) + 60)
break;
//在爬取每个item的时候判断这个item是否过期,如果这个item没有过期,就会记录这个item在之后多少秒内要过期
//然后根据对应的时间范围找到s->histo的位置+1,仔细看应该是跟上面的时间对应,如果距离爬取结束时间60s
//之后那么就取出刚才在爬取item时候记录的在之后60s内过期的item数量。
//s->histo[0] = 0~59s
//s->histo[1] = 60~119s
//s->histo[2] = 120~239s
//相当于记录当前时间到爬取结束时间这个范围内共有多少item即将过期
available_reclaims += s->histo[x];
}
//判断过期的item数量是否大于未过期的item数量百分之一
if (available_reclaims > low_watermark) {
//如果大于则重新置为0,这样下次循环的时候将重新添加爬虫去爬取.
last_crawls[i] = 0;
if (next_crawl_wait[i] > 60)
next_crawl_wait[i] -= 60;
//如果上面条件不满足,就会走下面的条件.
//考虑一种情况:
//假如since_run未过期的item数量有100000,那么low_watermark计算出来就等于1001
//而同样这些未过期的item过期时间都大于3600s,不在s->histo这个时间范围内那么
//available_reclaims计算出来就会一直小于low_watermark不会命中上面条件
} else if (since_run > 5 && since_run > next_crawl_wait[i]) {
last_crawls[i] = 0;
if (next_crawl_wait[i] < MAX_MAINTCRAWL_WAIT) //MAX_MAINTCRAWL_WAIT = (60 * 60)
next_crawl_wait[i] += 60;
}
if (settings.verbose > 1)
fprintf(stderr, "maint crawler: available reclaims: %llu, next_crawl: %u\n", (unsigned long long)available_reclaims, next_crawl_wait[i]);
}
pthread_mutex_unlock(&lru_crawler_stats_lock);
}
}
lru_crawler_start()
static int lru_crawler_start(uint32_t id, uint32_t remaining) {
int starts;
//这里说明下,刚才在上面的代码调用这个函数是在一个for循环,循环所有的 slab id
//看着像是依次添加所有slab id下的爬虫,但是根据规则不是这样的,一次只能保证添加
//成功一个slab id下的爬虫,因为第一个爬虫添加完之后爬虫线程就会运行然后加锁,而当
//循环到第二个 slab id 的时候在调用本函数添加爬虫就会添加失败,因为获取不到锁了
//只有等第一个 slab id 爬虫处理完毕之后释放了锁,才可以再添加,但是在添加哪个slab id
//下的爬虫就看当前循环到那个slab id了(有点类似于随机添加了)
//例如：
//第一次循环所有slab id：
// 【slab_id_1 添加成功、slab_id_2 添加失败、slab_id_3 添加失败、slab_id_4 添加成功(slab_id_1释放了锁)】
//第二次循环所有slab id：
// 【slab_id_1 不参与、slab_id_2 添加成功、slab_id_3 添加失败、slab_id_4 不参与】
//第三次循环所有slab id：
// 【slab_id_1 添加成功、slab_id_2不参与、slab_id_3添加成功(slab_id_1释放了锁)、slab_id_4 添加失败】
//不参与:就是添加成功之后修改爬虫状态last_crawls[i]不等于0了,所以只有等重新置为0之后在参与.
if (pthread_mutex_trylock(&lru_crawler_lock) != 0) {
return 0;
}
//添加爬虫
starts = do_lru_crawler_start(id, remaining);
if (starts) {
//添加完毕之后通知 item爬虫线程 运行
pthread_cond_signal(&lru_crawler_cond);
}
pthread_mutex_unlock(&lru_crawler_lock);
return starts;
}
do_lru_crawler_start()
static int do_lru_crawler_start(uint32_t id, uint32_t remaining) {
int i;
uint32_t sid;
uint32_t tocrawl[3];
int starts = 0;
//获取当前 slab id 下每个lru队列位置的索引
tocrawl[0] = id | HOT_LRU;
tocrawl[1] = id | WARM_LRU;
tocrawl[2] = id | COLD_LRU;
for (i = 0; i < 3; i++) {
//获取第一个队列id
sid = tocrawl[i];
//只对当前slab id下的 sid队列加锁, 把锁的颗粒度尽可能的降低
pthread_mutex_lock(&lru_locks[sid]);
//判断队列是否有值
if (tails[sid] != NULL) {
if (settings.verbose > 2)
fprintf(stderr, "Kicking LRU crawler off for LRU %d\n", sid);
//初始化一个爬虫item结构体
crawlers[sid].nbytes = 0;
crawlers[sid].nkey = 0;
crawlers[sid].it_flags = 1; /* 1:开启爬虫 0:关闭爬虫 */
crawlers[sid].next = 0;
crawlers[sid].prev = 0;
crawlers[sid].time = 0;
crawlers[sid].remaining = remaining;
crawlers[sid].slabs_clsid = sid;
//把这个爬虫item插入到当前队列的尾部,因为到时候item爬虫线程
//要去不断移动这个爬虫item,以达到获取到其他的item作用,直到移动
//到队列头部结束.
crawler_link_q((item *)&crawlers[sid]);
//记录要处理的lru队列数
crawler_count++;
starts++;
}
pthread_mutex_unlock(&lru_locks[sid]);
}
if (starts) {
//统计
STATS_LOCK();
stats.lru_crawler_running = true;
stats.lru_crawler_starts++;
STATS_UNLOCK();
pthread_mutex_lock(&lru_crawler_stats_lock);
memset(&crawlerstats[id], 0, sizeof(crawlerstats_t));
//记录下开始时间
crawlerstats[id].start_time = current_time;
pthread_mutex_unlock(&lru_crawler_stats_lock);
}
return starts;
}
爬虫item结构体
跟正常的item结构体差不多，只不过这个爬虫item结构体只用做标识作用，因为这个爬虫item最终是要插入到要爬取的lru队列中，然后在队列里面去不断移动它，从后往前进行移动，移动到什么位置就固定在什么位置，不会随其他item删除和添加进行变化，所以就是起到一个标识定位作用，而且用到的主要字段也就是 next、prev、it_flags
typedef struct {
struct _stritem *next;
struct _stritem *prev;
struct _stritem *h_next; /* hash chain next */
rel_time_t time; /* least recent access */
rel_time_t exptime; /* expire time */
int nbytes; /* size of data */
unsigned short refcount;
uint8_t nsuffix; /* length of flags-and-length string */
uint8_t it_flags; /* ITEM_* above */
uint8_t slabs_clsid;/* which slab class we're in */
uint8_t nkey; /* key length, w/terminating null and padding */
uint32_t remaining; /* Max keys to crawl per slab per invocation */
} crawler;
crawler_link_q() 爬虫item插入到lru队列尾部
static void crawler_link_q(item *it) { /* item is the new tail */
item **head, **tail;
assert(it->it_flags == 1);
assert(it->nbytes == 0);
//获取 slabs_clsid 下的队列 head、tail 对应的 item 地址
head = &heads[it->slabs_clsid];
tail = &tails[it->slabs_clsid];
assert(*tail != 0);
assert(it != *tail);
assert((*head && *tail) || (*head == 0 && *tail == 0));
//更换一下位置
it->prev = *tail;
it->next = 0;
if (it->prev) {
assert(it->prev->next == 0);
it->prev->next = it;
}
//插入到队列尾部
*tail = it;
if (*head == 0) *head = it;
return;
}
<b> 上面已经把爬虫添加到对应的队列了，并且也已经信号通知 item爬虫线程了，剩下就是看爬虫线程如何去爬取了</b>
item_crawler_thread() item爬虫线程函数
static void *item_crawler_thread(void *arg) {
int i;
//延时执行时间,默认1000
int crawls_persleep = settings.crawls_persleep;
pthread_mutex_lock(&lru_crawler_lock);
pthread_cond_signal(&lru_crawler_cond);
settings.lru_crawler = true;
if (settings.verbose > 2)
fprintf(stderr, "Starting LRU crawler background thread\n");
while (do_run_lru_crawler_thread) {
//这里就是在刚开始启动线程的时候处于挂起状态,直到上面添加完爬虫并且信号通知才会运行.
pthread_cond_wait(&lru_crawler_cond, &lru_crawler_lock);
//不断循环,直到处理完所有的队列crawler_count
while (crawler_count) {
item *search = NULL;
void *hold_lock = NULL;
//每次从0开始循环所有的队列,当那个队列发现有爬虫则处理
//但是只会处理一次,也就是相当于每次只移动一下当前lru队列的item爬虫
//然后继续循环处理第二个队列,在去移动第二条队列的item爬虫,为什么要这样
//因为我们在处理这条队列的时候会加锁,如果从尾部不断移动爬虫item到头部
//这个时间可能会比较长,同样锁的时间也会比较长,会导致其他线程在处理这个队列
//的时候处于堵塞状态,大大降低的并发度,所以这样去实现,每个队列发现有爬虫之后
//只处理移动一次,然后马上释放锁,等下次循环的时候再继续移动处理,降低锁的开销。
for (i = POWER_SMALLEST; i < LARGEST_ID; i++) {
if (crawlers[i].it_flags != 1) {
continue;
}
//加lru队列锁
pthread_mutex_lock(&lru_locks[i]);
//移动爬虫item,就是把当前爬虫item往上移动一位,然后把爬虫item下面的item返回
//item_1 -> item_2 -> crawler_item
//item_1 -> crawler_item -> item_2
search = crawler_crawl_q((item *)&crawlers[i]);
//如果等于空则代表移动到头部了
if (search == NULL ||
(crawlers[i].remaining && --crawlers[i].remaining < 1)) {
if (settings.verbose > 2)
fprintf(stderr, "Nothing left to crawl for %d\n", i);
//把当前lru队列的爬虫状态置为0
crawlers[i].it_flags = 0;
//已经处理完一条队列了,所以待处理的队列数减一
crawler_count--;
//把爬虫item从队列里面删除
crawler_unlink_q((item *)&crawlers[i]);
//解锁lru队列锁
pthread_mutex_unlock(&lru_locks[i]);
pthread_mutex_lock(&lru_crawler_stats_lock);
//更新下爬取结束时间
crawlerstats[CLEAR_LRU(i)].end_time = current_time;
//之前在lru_maintainer_crawler_check这个函数应该记得这个状态
//代表已经爬取完毕
crawlerstats[CLEAR_LRU(i)].run_complete = true;
pthread_mutex_unlock(&lru_crawler_stats_lock);
continue;
}
//获取hash值
uint32_t hv = hash(ITEM_key(search), search->nkey);
//对当前hash出的值加锁,就是段锁.
if ((hold_lock = item_trylock(hv)) == NULL) {
pthread_mutex_unlock(&lru_locks[i]);
continue;
}
//引用+1,如果不等于1,则代表当前item可能正在忙
if (refcount_incr(&search->refcount) != 2) {
refcount_decr(&search->refcount);
if (hold_lock)
item_trylock_unlock(hold_lock);
pthread_mutex_unlock(&lru_locks[i]);
continue;
}
pthread_mutex_lock(&lru_crawler_stats_lock);
//主要做检查item是否过期删除操作处理等
item_crawler_evaluate(search, hv, i);
pthread_mutex_unlock(&lru_crawler_stats_lock);
if (hold_lock)
item_trylock_unlock(hold_lock);
pthread_mutex_unlock(&lru_locks[i]);
//循环完一次,需要延时多久再继续,如果设置了的话
if (crawls_persleep <= 0 && settings.lru_crawler_sleep) {
usleep(settings.lru_crawler_sleep);
crawls_persleep = settings.crawls_persleep;
}
}
}
if (settings.verbose > 2)
fprintf(stderr, "LRU crawler thread sleeping\n");
STATS_LOCK();
stats.lru_crawler_running = false;
STATS_UNLOCK();
}
pthread_mutex_unlock(&lru_crawler_lock);
if (settings.verbose > 2)
fprintf(stderr, "LRU crawler thread stopping\n");
return NULL;
}
item_crawler_evaluate()
static void item_crawler_evaluate(item *search, uint32_t hv, int i) {
int slab_id = CLEAR_LRU(i);
//获取slab_id下的爬虫统计信息
crawlerstats_t *s = &crawlerstats[slab_id];
itemstats[i].crawler_items_checked++;
//判断当前item是否过期
if ((search->exptime != 0 && search->exptime < current_time)
|| item_is_flushed(search)) {
itemstats[i].crawler_reclaimed++;
s->reclaimed++;
if (settings.verbose > 1) {
int ii;
char *key = ITEM_key(search);
fprintf(stderr, "LRU crawler found an expired item (flags: %d, slab: %d): ",
search->it_flags, search->slabs_clsid);
for (ii = 0; ii < search->nkey; ++ii) {
fprintf(stderr, "%c", key[ii]);
}
fprintf(stderr, "\n");
}
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 {
//如果没有过期item则记录数量,之前在lru_maintainer_crawler_check这个函数也有体现这块
s->seen++;
refcount_decr(&search->refcount);
if (search->exptime == 0) {
s->noexp++; //永不过期数量
} else if (search->exptime - current_time > 3599) {
s->ttl_hourplus++; //大于3600s之后过期数量
} else {
//记录在多久之后过期的item数量 例如: 1~59s、60~119s、120~179s
//按对应的时间段记录
rel_time_t ttl_remain = search->exptime - current_time;
int bucket = ttl_remain / 60;
s->histo[bucket]++;
}
}
}
以上介绍的就是 Memcache 的 item爬虫 核心代码实现！！ 开启爬虫也确实有对应的好处，如果系统有大量过期的item不回收，占用大量资源不说，有可能还会导致item不够用的情况然后马上就会进行lru淘汰这就可能会导致把未过期的item淘汰，还有就是hash表会随着item增多不断的自动扩容，消耗更多的内存，而且也会加大其迁移工作量，毕竟一直没有删除这些过期的item，那么就会一直占用其位置，但开启爬虫也有不好的地方，加大服务器负担、占用内存、锁争抢、等问题。
<a id="3F"> slab 爬虫线程，相关代码分析</a>
Memcache-slab回收chunk
上面在 lru_maintainer_juggle 函数里有这么一块代码，就是触发slab维护爬虫线程的
static int lru_maintainer_juggle(const int slabs_clsid) {
//....
chunks_free = slabs_available_chunks(slabs_clsid, &mem_limit_reached,
&total_chunks, &chunks_perslab);
if (settings.slab_automove > 0 && chunks_free > (chunks_perslab * 2.5)) {
slabs_reassign(slabs_clsid, SLAB_GLOBAL_PAGE_POOL);
}
//....
}
slabs_reassign()
enum reassign_result_type slabs_reassign(int src, int dst) {
enum reassign_result_type ret;
if (pthread_mutex_trylock(&slabs_rebalance_lock) != 0) {
return REASSIGN_RUNNING;
}
//src : 要回收哪个 slab_id 下的 chunk
//dst : 将回收的 chunk 移动到 slab_id = 0 的位置（这个是固定的位置）
ret = do_slabs_reassign(src, dst);
pthread_mutex_unlock(&slabs_rebalance_lock);
return ret;
}
do_slabs_reassign()
static enum reassign_result_type do_slabs_reassign(int src, int dst) {
//是否 slab 线程正在工作,如果正在工作则不在通知该线程进行处理了
if (slab_rebalance_signal != 0)
return REASSIGN_RUNNING;
if (src == dst)
return REASSIGN_SRC_DST_SAME;
/* Special indicator to choose ourselves. */
if (src == -1) {
src = slabs_reassign_pick_any(dst);
/* TODO: If we end up back at -1, return a new error type */
}
if (src < POWER_SMALLEST || src > power_largest ||
dst < SLAB_GLOBAL_PAGE_POOL || dst > power_largest)
return REASSIGN_BADCLASS;
//如果该 slab id 下的 chunk 小于2块则不回收了.
if (slabclass[src].slabs < 2)
return REASSIGN_NOSPARE;
//赋值全局变量，在slab爬虫线程中会获取
//s_clsid 要回收的 slab id
//d_clsid 回收之后移动到该 slab id 下
slab_rebal.s_clsid = src;
slab_rebal.d_clsid = dst;
//修改状态,跟上面判断对应,代表已经通知slab爬虫线程了
slab_rebalance_signal = 1;
//通知slab爬虫线程信号
pthread_cond_signal(&slab_rebalance_cond);
return REASSIGN_OK;
}
slab_rebalance_thread slab 爬虫线程函数
static void *slab_rebalance_thread(void *arg) {
int was_busy = 0;
/* So we first pass into cond_wait with the mutex held */
mutex_lock(&slabs_rebalance_lock);
//死循环
while (do_run_slab_rebalance_thread) {
//在第一次循环的时候会命中此条件,因为刚才上面的函数已经把该变量设置为1了
if (slab_rebalance_signal == 1) {
//获取当前要回收的 slab id 信息
if (slab_rebalance_start() < 0) {
/* Handle errors with more specifity as required. */
slab_rebalance_signal = 0;
}
was_busy = 0;
//如果slab_rebalance_start()函数执行成功会把slab_rebalance_signal修改成2
//所以在下次循环的时候就会命中此条件
} else if (slab_rebalance_signal && slab_rebal.slab_start != NULL) {
//上面获取到要回收的 slab id 信息之后,马上去回收一块 chunk
was_busy = slab_rebalance_move();
}
//是否回收完毕
if (slab_rebal.done) {
//做一些收尾清理工作
slab_rebalance_finish();
} else if (was_busy) {
/* Stuck waiting for some items to unlock, so slow down a bit
* to give them a chance to free up */
usleep(50);
}
//如果等于0重新处于挂起状态
if (slab_rebalance_signal == 0) {
/* always hold this lock while we're running */
pthread_cond_wait(&slab_rebalance_cond, &slabs_rebalance_lock);
}
}
return NULL;
}
slab_rebalance_start()
static int slab_rebalance_start(void) {
slabclass_t *s_cls;
int no_go = 0;
//只要对slab区操作就要加锁,这里的加锁是针对全局的 slab_id[1~63]
//所以锁的开销稍微大一些
pthread_mutex_lock(&slabs_lock);
if (slab_rebal.s_clsid < POWER_SMALLEST ||
slab_rebal.s_clsid > power_largest ||
slab_rebal.d_clsid < SLAB_GLOBAL_PAGE_POOL ||
slab_rebal.d_clsid > power_largest ||
slab_rebal.s_clsid == slab_rebal.d_clsid)
no_go = -2;
//取出s_clsid信息
s_cls = &slabclass[slab_rebal.s_clsid];
//之前在内存模型源码分析文章中已经说明此函数了,就是申请一块内存来保存chunk地址
//而这个就是对d_clsid这个区申请内存来保存chunk地址,因为最后chunk回收完都会移动d_clsid这个区
if (!grow_slab_list(slab_rebal.d_clsid)) {
no_go = -1;
}
//在判断一次当前slab下的 chunk 是否小于2块
if (s_cls->slabs < 2)
no_go = -3;
if (no_go != 0) {
pthread_mutex_unlock(&slabs_lock);
return no_go; /* Should use a wrapper function... */
}
//获取s_cls下第一块chunk的开始地址
slab_rebal.slab_start = s_cls->slab_list[0];
//获取s_cls下第一块chunk的结束地址
slab_rebal.slab_end = (char *)slab_rebal.slab_start +
(s_cls->size * s_cls->perslab);
//移动下标,因为在回收chunk的时候,需要把这个chunk里面已使用的item
//全部复制到其他的chunk内,好把当前的chunk腾出来,所以就需要靠这个
//下标根据item的大小,不断的往后移动指针以达到获取每一个item的作用,直到结束。
slab_rebal.slab_pos = slab_rebal.slab_start;
//回收状态 1:已回收 0:未回收
slab_rebal.done = 0;
//更改状态为2
slab_rebalance_signal = 2;
if (settings.verbose > 1) {
fprintf(stderr, "Started a slab rebalance\n");
}
//解锁
pthread_mutex_unlock(&slabs_lock);
STATS_LOCK();
stats.slab_reassign_running = true;
STATS_UNLOCK();
return 0;
}
slab_rebalance_move()
static int slab_rebalance_move(void) {
slabclass_t *s_cls;
int x;
int was_busy = 0;
int refcount = 0;
uint32_t hv;
void *hold_lock;
enum move_status status = MOVE_PASS;
//加锁
pthread_mutex_lock(&slabs_lock);
//取出slab信息
s_cls = &slabclass[slab_rebal.s_clsid];
//这里默认一次只循环一次,也就是在移除chunk里面item的时候,一次只移除一个item
//不过可以在启动的时候设定这个slab_bulk_check循环次数
//尽可能的还是把这个变量设置小一些,保证只循环一次就退出循环,因为这样可以减小锁的颗粒度
//可以看到上面slab是全局锁,如果我们当前这个slab id一直占用锁,会导致其它的slab id
//也都无法操作,所以这里每次循环处理完一个item之后马上释放锁,然后在获取锁在进行处理.
for (x = 0; x < slab_bulk_check; x++) {
hv = 0;
hold_lock = NULL;
//获取item
item *it = slab_rebal.slab_pos;
status = MOVE_PASS;
//判断 it_flags 是不是不等于这两个状态组合,默认情况不会等于
//会等到该item移除完毕之后才会赋值成这两个状态组合
if (it->it_flags != (ITEM_SLABBED|ITEM_FETCHED)) {
//是否空闲的item
if (it->it_flags & ITEM_SLABBED) {
//把当前item从空闲s_cls->slots链表移动出来，因为我们要回收这个chunk
//所以这个chunk里面的item就不能在被当前slab引用了.
if (s_cls->slots == it) {
s_cls->slots = it->next;
}
if (it->next) it->next->prev = it->prev;
if (it->prev) it->prev->next = it->next;
//减一下空闲item数量
s_cls->sl_curr--;
status = MOVE_FROM_SLAB;
//是否被使用的item
} else if ((it->it_flags & ITEM_LINKED) != 0) {
//获取hash锁
hv = hash(ITEM_key(it), it->nkey);
if ((hold_lock = item_trylock(hv)) == NULL) {
//如果没有抢到锁,则代表这个item正在忙
status = MOVE_LOCKED;
} else {
//引用+1
refcount = refcount_incr(&it->refcount);
//如果等于 2 则代表目前没有其他线程在使用这个item
if (refcount == 2) {
//在判断一次是否被使用的item
if ((it->it_flags & ITEM_LINKED) != 0) {
//把这个被使用的item复制到其他chunk下
status = MOVE_FROM_LRU;
} else {
//如果不是则可能刚巧同一时间被删除了,所以改成正在忙的状态,下次循环再看一次
status = MOVE_BUSY;
}
} else {
if (settings.verbose > 2) {
fprintf(stderr, "Slab reassign hit a busy item: refcount: %d (%d -> %d)\n",
it->refcount, slab_rebal.s_clsid, slab_rebal.d_clsid);
}
//如果引用+1不等于2则代表其他线程正在操作该item,正在忙
status = MOVE_BUSY;
}
/* Item lock must be held while modifying refcount */
if (status == MOVE_BUSY) {
//引用-1
refcount_decr(&it->refcount);
//释放hash锁
item_trylock_unlock(hold_lock);
}
}
} else {
/* See above comment. No ITEM_SLABBED or ITEM_LINKED. Mark
* busy and wait for item to complete its upload. */
status = MOVE_BUSY;
}
}
int save_item = 0;
item *new_it = NULL;
size_t ntotal = 0;
switch (status) {
case MOVE_FROM_LRU:
//当前item总占用字节数
ntotal = ITEM_ntotal(it);
//判断是否过期了
if ((it->exptime != 0 && it->exptime < current_time)
|| item_is_flushed(it)) {
/* TODO: maybe we only want to save if item is in HOT or
* WARM LRU?
*/
save_item = 0;
//去其他chunk下获取一个空闲的item
} else if ((new_it = slab_rebalance_alloc(ntotal, slab_rebal.s_clsid)) == NULL) {
save_item = 0;
slab_rebal.evictions_nomem++;
} else {
save_item = 1;
}
pthread_mutex_unlock(&slabs_lock);
if (save_item) {
//把当前的item内容copy到新的new_it下
memcpy(new_it, it, ntotal);
new_it->prev = 0;
new_it->next = 0;
new_it->h_next = 0;
/* These are definitely required. else fails assert */
new_it->it_flags &= ~ITEM_LINKED;
new_it->refcount = 0;
//把当前 item 引用全部释放掉
//在把新的 new_it 全部引用上
//这样就相当于把当前 item 移动copy到其他 chunk 下了,把当前 item 位置腾出来了
do_item_replace(it, new_it, hv);
slab_rebal.rescues++;
} else {
//把当前 item 引用全部释放掉
do_item_unlink(it, hv);
}
/*
如果仔细观察代码的会发现一个疑点,这个item在上面会引用+1操作 refcount_incr(&it->refcount)
但是在释放item的时候并没有先去引用减一,这就可能导致我们这个item不会被全部释放掉,因为全部释放掉
的条件是引用减一等于0才可以,但是很显然我们目前item的引用等于2,所以减一肯定不等于0,这样的话就只
会释放掉 hash表引用、lru队列引用,而不会重新把这个item加入到空闲的item链表slots去, 所以并没有全
部释放掉.
为什么要这样做?
实际上就是故意不让它全部释放掉的,如果全部释放掉,就会把我们这个item重新加入到空闲的item链表里面去
这就导致我们好不容易把当前这个正在使用的item复制到别的chunk下面去了,然后释放掉了,但是马上又被使用
了,因为加入到空闲item链表里面去了啊,所以故意引用+1之后不在引用-1,这就就能保证我们这个item不会再被
使用了,也就相当于把这个item彻底移除了.
*/
//释放hash锁
item_trylock_unlock(hold_lock);
//释放slab锁
pthread_mutex_lock(&slabs_lock);
//把当前item占用的字节数从总占用字节数里面减去
s_cls->requested -= ntotal;
case MOVE_FROM_SLAB:
it->refcount = 0;
it->it_flags = ITEM_SLABBED|ITEM_FETCHED; //更新flags状态
#ifdef DEBUG_SLAB_MOVER
memcpy(ITEM_key(it), "deadbeef", 8);
#endif
break;
case MOVE_BUSY:
case MOVE_LOCKED:
//记录一下正在忙的item数量
slab_rebal.busy_items++;
was_busy++;
break;
case MOVE_PASS:
break;
}
//如果本次 item 正在忙没有移动走, 那么也会把指针移动到下个 item 的位置, 处理下个 item
//等这一圈全部循环完之后,回过头来发现刚才有正在忙的item没有移动走,那么会再继续循环一轮
//直到把chunk内所有item全部移除完毕。
slab_rebal.slab_pos = (char *)slab_rebal.slab_pos + s_cls->size;
if (slab_rebal.slab_pos >= slab_rebal.slab_end)
break;
}
//判断是否处理完所有item
if (slab_rebal.slab_pos >= slab_rebal.slab_end) {
// 判断是否有正在忙的item
if (slab_rebal.busy_items) {
//如果有则重新把slab_pos指针重置到开始位置,然后重新一轮循环处理
slab_rebal.slab_pos = slab_rebal.slab_start;
STATS_LOCK();
stats.slab_reassign_busy_items += slab_rebal.busy_items;
STATS_UNLOCK();
//清零
slab_rebal.busy_items = 0;
} else {
//当前chunk内所有item移除完毕
slab_rebal.done++;
}
}
pthread_mutex_unlock(&slabs_lock);
return was_busy;
}
slab_rebalance_finish()
static void slab_rebalance_finish(void) {
slabclass_t *s_cls;
slabclass_t *d_cls;
int x;
uint32_t rescues;
uint32_t evictions_nomem;
uint32_t inline_reclaim;
pthread_mutex_lock(&slabs_lock);
s_cls = &slabclass[slab_rebal.s_clsid];
d_cls = &slabclass[slab_rebal.d_clsid];
//因为我们回收了一个chunk所以把chunk数量减一
s_cls->slabs--;
//更新保存chunk地址,由于第一个chunk地址被回收,所以第二个chunk地址挪到数组的第一个位置,以此类推
for (x = 0; x < s_cls->slabs; x++) {
s_cls->slab_list[x] = s_cls->slab_list[x+1];
}
//把刚才回收的chunk地址保存到d_clsid下面
d_cls->slab_list[d_cls->slabs++] = slab_rebal.slab_start;
/* Don't need to split the page into chunks if we're just storing it */
if (slab_rebal.d_clsid > SLAB_GLOBAL_PAGE_POOL) {
memset(slab_rebal.slab_start, 0, (size_t)settings.item_size_max);
split_slab_page_into_freelist(slab_rebal.slab_start,
slab_rebal.d_clsid);
}
//因为已经回收完毕一个chunk,所以重置下
slab_rebal.done = 0;
slab_rebal.s_clsid = 0;
slab_rebal.d_clsid = 0;
slab_rebal.slab_start = NULL;
slab_rebal.slab_end = NULL;
slab_rebal.slab_pos = NULL;
evictions_nomem = slab_rebal.evictions_nomem;
inline_reclaim = slab_rebal.inline_reclaim;
rescues = slab_rebal.rescues;
slab_rebal.evictions_nomem = 0;
slab_rebal.inline_reclaim = 0;
slab_rebal.rescues = 0;
//爬虫运行状态重新改为0
slab_rebalance_signal = 0;
pthread_mutex_unlock(&slabs_lock);
//统计
STATS_LOCK();
stats.slab_reassign_running = false;
stats.slabs_moved++;
stats.slab_reassign_rescues += rescues;
stats.slab_reassign_evictions_nomem += evictions_nomem;
stats.slab_reassign_inline_reclaim += inline_reclaim;
STATS_UNLOCK();
if (settings.verbose > 1) {
fprintf(stderr, "finished a slab move\n");
}
}
<b> 上面就是回收指定slab下chunk的流程，但是回收的这个chunk什么时候会在被使用到？ 其实在获取一个slab id下的item来使用的时候，如果空闲item链表被全部消耗没了，就会在去内存池申请一个chunk重新划分item，但是如果我们回收的chunk存在，就会优先去使用这个回收的chunk</b>
do_slabs_newslab()
//获取一个slab id下的 chunk
static int do_slabs_newslab(const unsigned int id) {
slabclass_t *p = &slabclass[id];
slabclass_t *g = &slabclass[SLAB_GLOBAL_PAGE_POOL];
int len = settings.slab_reassign ? settings.item_size_max
: p->size * p->perslab;
char *ptr;
if ((mem_limit && mem_malloced + len > mem_limit && p->slabs > 0
&& g->slabs == 0)) {
mem_limit_reached = true;
MEMCACHED_SLABS_SLABCLASS_ALLOCATE_FAILED(id);
return 0;
}
//get_page_from_global_pool 这个函数就是获取回收的chunk
//如果没有就会调用 memory_allocate() 去内存池申请一个chunk
//可以看到优先去使用回收的chunk
if ((grow_slab_list(id) == 0) ||
(((ptr = get_page_from_global_pool()) == NULL) &&
((ptr = memory_allocate((size_t)len)) == 0))) {
MEMCACHED_SLABS_SLABCLASS_ALLOCATE_FAILED(id);
return 0;
}
memset(ptr, 0, (size_t)len);
split_slab_page_into_freelist(ptr, id);
p->slab_list[p->slabs++] = ptr;
MEMCACHED_SLABS_SLABCLASS_ALLOCATE(id);
return 1;
}
get_page_from_global_pool()
static void *get_page_from_global_pool(void) {
//#define SLAB_GLOBAL_PAGE_POOL 0
//就是保存我们回收chunk的slab区
slabclass_t *p = &slabclass[SLAB_GLOBAL_PAGE_POOL];
if (p->slabs < 1) {
return NULL;
}
//获取一个回收的chunk地址
char *ret = p->slab_list[p->slabs - 1];
p->slabs--;
//返回地址
return ret;
}
以上介绍的就是 Memcache 的 slab爬虫 核心代码实现！！ 如果开启的话就会帮我们不断的维护slab下chunk块，不会出现所有的chunk都被一个slab区占用的情况因为当空闲item数量达到一定的阀值就会回收一个chunk做预留，如果其他slab区要使用就可以获取这个预留的来使用。
<a id="2F"> lru 维护爬虫线程, 相关代码分析 </a>
还是在 lru_maintainer_juggle 这个函数里面去调用相关代码处理，之前在介绍这个函数的时候会去触发slab维护爬虫线程，触发完了之后就会调用以下代码进行lru队列维护工作
static int lru_maintainer_juggle(const int slabs_clsid) {
//.......
//循环1000次调整指定 slabs_clsid 下面的三条队列的 item
for (i = 0; i < 1000; i++) {
int do_more = 0;
//先去调整HOT_LRU队列如果没有被移出的则马上在调整WARM_LRU队列
if (lru_pull_tail(slabs_clsid, HOT_LRU, total_chunks, false, 0) ||
lru_pull_tail(slabs_clsid, WARM_LRU, total_chunks, false, 0)) {
do_more++;
}
//最后调整COLD_LRU队列
do_more += lru_pull_tail(slabs_clsid, COLD_LRU, total_chunks, false, 0);
//如果一个item都没有被移除则跳出
if (do_more == 0)
break;
//调整次数
did_moves++;
}
return did_moves;
}
lru_pull_tail() 调整lru队列链表
static int lru_pull_tail(const int orig_id, const int cur_lru,
const unsigned int total_chunks, const bool do_evict, const uint32_t cur_hv) {
item *it = NULL;
int id = orig_id;
int removed = 0;
if (id == 0)
return 0;
//下面for循环次数
int tries = 5;
item *search;
item *next_it;
void *hold_lock = NULL;
unsigned int move_to_lru = 0;
uint64_t limit;
//通过当前 slab id 计算出当前 lru 队列的 id
id |= cur_lru;
//lru队列加锁
pthread_mutex_lock(&lru_locks[id]);
//获取当前队列最后一个item
search = tails[id];
//共循环5次,也就代表可以调整当前队列下5个item
for (; tries > 0 && search != NULL; tries--, search=next_it) {
//获取上一个item
next_it = search->prev;
if (search->nbytes == 0 && search->nkey == 0 && search->it_flags == 1) {
/* We are a crawler, ignore it. */
tries++;
continue;
}
//获取hash值
uint32_t hv = hash(ITEM_key(search), search->nkey);
//加锁,如果加不上锁则代表别的线程正在访问该item,忽略
if (hv == cur_hv || (hold_lock = item_trylock(hv)) == NULL)
continue;
//正常该item引用+1应该等于2,但是如果引用+1之后不等于2可能当前item就有问题了
//因为有可能这种情况,当前一个线程获取一个item然后引用+1,但是由于某些原因,最
//后结束的时候并没引用-1,所以这里判断就有可能不等于2而等于3的情况
if (refcount_incr(&search->refcount) != 2) {
itemstats[id].lrutail_reflocked++;
//然后判断一下该item访问时间加上settings.tail_repair_time是否小于当前时间
//如果小于当前时间则代表这个item在这一段时间内并没有引用-1,所以是个异常退
//出的item
if (settings.tail_repair_time &&
search->time + settings.tail_repair_time < current_time) {
itemstats[id].tailrepairs++;
search->refcount = 1;
//释放掉该item,就是删除
do_item_unlink_nolock(search, hv);
//hash解锁
item_trylock_unlock(hold_lock);
continue;
}
}
//判断item是否过期
if ((search->exptime != 0 && search->exptime < current_time)
|| item_is_flushed(search)) {
itemstats[id].reclaimed++;
if ((search->it_flags & ITEM_FETCHED) == 0) {
itemstats[id].expired_unfetched++;
}
//删除
/* refcnt 2 -> 1 */
do_item_unlink_nolock(search, hv);
/* refcnt 1 -> 0 -> item_free */
do_item_remove(search);
//hash解锁
item_trylock_unlock(hold_lock);
removed++;
/* If all we're finding are expired, can keep going */
continue;
}
/* If we're HOT_LRU or WARM_LRU and over size limit, send to COLD_LRU.
* If we're COLD_LRU, send to WARM_LRU unless we need to evict
*/
switch (cur_lru) {
case HOT_LRU:
//获取 HOT_LRU 队列的 item 比例阀值
limit = total_chunks * settings.hot_lru_pct / 100;
case WARM_LRU:
//获取 WARM_LRU 队列的 item 比例阀值
limit = total_chunks * settings.warm_lru_pct / 100;
//如果超过阀值则把当前item移动到COLD_LRU队列
if (sizes[id] > limit) {
itemstats[id].moves_to_cold++;
//代表把当前item插入到COLD_LRU队列
move_to_lru = COLD_LRU;
//从当前队列删除
do_item_unlink_q(search);
//记录下当前item的指针
it = search;
//移除数量+1
removed++;
break;
//判断当前item是否正在活动的item
} else if ((search->it_flags & ITEM_ACTIVE) != 0) {
itemstats[id].moves_within_lru++;
//把正在活动的状态去除
search->it_flags &= ~ITEM_ACTIVE;
//把当前item从当前队列尾部删除然后重新插入到队头
//因为这个item被访问了是个热数据,所以移动到队头去
//防止当前队列超过阀值队尾的item被移动冷队列COLD_LRU
do_item_update_nolock(search);
//上面引用+1了所以调用这个函数只会引用-1操作,不会被释放掉
do_item_remove(search);
//hash解锁
item_trylock_unlock(hold_lock);
} else {
/* Don't want to move to COLD, not active, bail out */
it = search;
}
break;
case COLD_LRU:
it = search; /* No matter what, we're stopping */
//如果do_evict为true则强制把当前item淘汰,这块一般用在
//获取一个空闲item获取不到的情况,然后强制逐出一个
if (do_evict) {
if (settings.evict_to_free == 0) {
/* Don't think we need a counter for this. It'll OOM. */
break;
}
itemstats[id].evicted++;
itemstats[id].evicted_time = current_time - search->time;
if (search->exptime != 0)
itemstats[id].evicted_nonzero++;
if ((search->it_flags & ITEM_FETCHED) == 0) {
itemstats[id].evicted_unfetched++;
}
//删除
do_item_unlink_nolock(search, hv);
removed++;
if (settings.slab_automove == 2) {
slabs_reassign(-1, orig_id);
}
//判断当前item是否正在活动的item
} else if ((search->it_flags & ITEM_ACTIVE) != 0
&& settings.lru_maintainer_thread) {
itemstats[id].moves_to_warm++;
//去掉活动状态
search->it_flags &= ~ITEM_ACTIVE;
//代表把当前item插入到WARM_LRU队列
move_to_lru = WARM_LRU;
//从当前队列删除
do_item_unlink_q(search);
removed++;
}
break;
}
if (it != NULL)
break;
}
//lru队列解锁
pthread_mutex_unlock(&lru_locks[id]);
if (it != NULL) {
//这块就是上面由当前队列移动到其他队列的状态值
if (move_to_lru) {
it->slabs_clsid = ITEM_clsid(it);
//把当前item在lru队列的id修改至move_to_lru这个队列的id
it->slabs_clsid |= move_to_lru;
//插入队列
item_link_q(it);
}
//引用-1或者直接删除
do_item_remove(it);
//hash解锁
item_trylock_unlock(hold_lock);
}
return removed;
}
以上介绍的就是 Memcache 的 lru维护爬虫 核心代码实现！！ 核心代码就是上面这个函数，不断的维护每个slab下的三条队列，前提是开启lru维护线程的情况，然后系统就会帮我们去不断的维护区分冷热数据，这样在强制淘汰item的时候，尽可能的不把热数据淘汰掉只淘汰冷数据，所以根据实际情况选择开启还是不开启即可。
结束
上面已经把 Memcache 这几个爬虫线程全部介绍完毕，想开启那个线程根据实际情况确认开启即可，这里系统可以自动去调用并通知对应的爬虫线程工作，但前提是开启lru维护线程的情况，由lru维护线程统一去调度，但同时也可以由客户端通过发送命令去触发对应的爬虫线程工作，我们上边讲的是在lru维护线程里面自动去触发其它的爬虫线程，也就相当于是系统自动去调用并触发，大概的流程就是先执行lru维护线程，然后触发slab维护爬虫线程，在触发item爬虫线程，最后执行lru队列维护就是这么一个流程，因为代码逻辑很难用文字表达特别清楚，所以以上有说错或者描述不准确的地方请告知，这里一定会及时修改。
