MemCache是什么
MemCache是一个自由、源码开放、高性能、分布式的分布式内存对象缓存系统,用于动态Web应用以减轻数据库的负载。它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高了网站访问的速度。MemCaChe是一个存储键值对的HashMap,在内存中对任意的数据(比如字符串、对象等)所使用的key-value存储,数据可以来自数据库调用、API调用,或者页面渲染的结果。MemCache设计理念就是小而强大,它简单的设计促进了快速部署、易于开发并解决面对大规模的数据缓存的许多难题,而所开放的API使得MemCache能用于Java、C/C++/C#、Perl、Python、PHP、Ruby等大部分流行的程序语言。
另外,说一下MemCache和MemCached的区别:
1、MemCache是项目的名称
2、MemCached是MemCache服务器端可以执行文件的名称
MemCache的官方网站为http://memcached.org/
MemCache访问模型
为了加深理解,我模仿着原阿里技术专家李智慧老师《大型网站技术架构 核心原理与案例分析》一书MemCache部分,自己画了一张图:
特别澄清一个问题,MemCache虽然被称为"分布式缓存",但是MemCache本身完全不具备分布式的功能,MemCache集群之间不会相互通信(与之形成对比的,比如JBoss Cache,某台服务器有缓存数据更新时,会通知集群中其他机器更新缓存或清除缓存数据),所谓的"分布式",完全依赖于客户端程序的实现,就像上面这张图的流程一样。
同时基于这张图,理一下MemCache一次写缓存的流程:
1、应用程序输入需要写缓存的数据
2、API将Key输入路由算法模块,路由算法根据Key和MemCache集群服务器列表得到一台服务器编号
3、由服务器编号得到MemCache及其的ip地址和端口号
4、API调用通信模块和指定编号的服务器通信,将数据写入该服务器,完成一次分布式缓存的写操作
读缓存和写缓存一样,只要使用相同的路由算法和服务器列表,只要应用程序查询的是相同的Key,MemCache客户端总是访问相同的客户端去读取数据,只要服务器中还缓存着该数据,就能保证缓存命中。
这种MemCache集群的方式也是从分区容错性的方面考虑的,假如Node2宕机了,那么Node2上面存储的数据都不可用了,此时由于集群中Node0和Node1还存在,下一次请求Node2中存储的Key值的时候,肯定是没有命中的,这时先从数据库中拿到要缓存的数据,然后路由算法模块根据Key值在Node0和Node1中选取一个节点,把对应的数据放进去,这样下一次就又可以走缓存了,这种集群的做法很好,但是缺点是成本比较大。
一致性Hash算法
从上面的图中,可以看出一个很重要的问题,就是对服务器集群的管理,路由算法至关重要,就和负载均衡算法一样,路由算法决定着究竟该访问集群中的哪台服务器,先看一个简单的路由算法。
1、余数Hash
比方说,字符串str对应的HashCode是50、服务器的数目是3,取余数得到2,str对应节点Node2,所以路由算法把str路由到Node2服务器上。由于HashCode随机性比较强,所以使用余数Hash路由算法就可以保证缓存数据在整个MemCache服务器集群中有比较均衡的分布。
如果不考虑服务器集群的伸缩性(什么是伸缩性,请参见大型网站架构学习笔记),那么余数Hash算法几乎可以满足绝大多数的缓存路由需求,但是当分布式缓存集群需要扩容的时候,就难办了。
就假设MemCache服务器集群由3台变为4台吧,更改服务器列表,仍然使用余数Hash,50对4的余数是2,对应Node2,但是str原来是存在Node1上的,这就导致了缓存没有命中。如果这么说不够明白,那么不妨举个例子,原来有HashCode为0~19的20个数据,那么:
HashCode | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 |
路由到的服务器 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 |
现在我扩容到4台,加粗标红的表示命中:
HashCode | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 |
路由到的服务器 | 0 | 1 | 2 | 3 | 0 | 1 | 2 | 3 | 0 | 1 | 2 | 3 | 0 | 1 | 2 | 3 | 0 | 1 | 2 | 3 |
如果我扩容到20+的台数,只有前三个HashCode对应的Key是命中的,也就是15%。当然这只是个简单例子,现实情况肯定比这个复杂得多,不过足以说明,使用余数Hash的路由算法,在扩容的时候会造成大量的数据无法正确命中(其实不仅仅是无法命中,那些大量的无法命中的数据还在原缓存中在被移除前占据着内存)。这个结果显然是无法接受的,在网站业务中,大部分的业务数据度操作请求上事实上是通过缓存获取的,只有少量读操作会访问数据库,因此数据库的负载能力是以有缓存为前提而设计的。当大部分被缓存了的数据因为服务器扩容而不能正确读取时,这些数据访问的压力就落在了数据库的身上,这将大大超过数据库的负载能力,严重的可能会导致数据库宕机。
这个问题有解决方案,解决步骤为:
(1)在网站访问量低谷,通常是深夜,技术团队加班,扩容、重启服务器
(2)通过模拟请求的方式逐渐预热缓存,使缓存服务器中的数据重新分布
2、一致性Hash算法
一致性Hash算法通过一个叫做一致性Hash环的数据结构实现Key到缓存服务器的Hash映射,看一下我自己画的一张图:
具体算法过程为:先构造一个长度为232的整数环(这个环被称为一致性Hash环),根据节点名称的Hash值(其分布为[0, 232-1])将缓存服务器节点放置在这个Hash环上,然后根据需要缓存的数据的Key值计算得到其Hash值(其分布也为[0, 232-1]),然后在Hash环上顺时针查找距离这个Key值的Hash值最近的服务器节点,完成Key到服务器的映射查找。
就如同图上所示,三个Node点分别位于Hash环上的三个位置,然后Key值根据其HashCode,在Hash环上有一个固定位置,位置固定下之后,Key就会顺时针去寻找离它最近的一个Node,把数据存储在这个Node的MemCache服务器中。使用Hash环如果加了一个节点会怎么样,看一下:
看到我加了一个Node4节点,只影响到了一个Key值的数据,本来这个Key值应该是在Node1服务器上的,现在要去Node4了。采用一致性Hash算法,的确也会影响到整个集群,但是影响的只是加粗的那一段而已,相比余数Hash算法影响了远超一半的影响率,这种影响要小得多。更重要的是,集群中缓存服务器节点越多,增加节点带来的影响越小,很好理解。换句话说,随着集群规模的增大,继续命中原有缓存数据的概率会越来越大,虽然仍然有小部分数据缓存在服务器中不能被读到,但是这个比例足够小,即使访问数据库,也不会对数据库造成致命的负载压力。
至于具体应用,这个长度为232的一致性Hash环通常使用二叉查找树实现,至于二叉查找树,就是算法的问题了,可以自己去查询相关资料。
MemCache实现原理
首先要说明一点,MemCache的数据存放在内存中,存放在内存中个人认为意味着几点:
1、访问数据的速度比传统的关系型数据库要快,因为Oracle、MySQL这些传统的关系型数据库为了保持数据的持久性,数据存放在硬盘中,IO操作速度慢
2、MemCache的数据存放在内存中同时意味着只要MemCache重启了,数据就会消失
3、既然MemCache的数据存放在内存中,那么势必受到机器位数的限制,这个之前的文章写过很多次了,32位机器最多只能使用2GB的内存空间,64位机器可以认为没有上限
然后我们来看一下MemCache的原理,MemCache最重要的莫不是内存分配的内容了,MemCache采用的内存分配方式是固定空间分配,还是自己画一张图说明:
这张图片里面涉及了slab_class、slab、page、chunk四个概念,它们之间的关系是:
1、MemCache将内存空间分为一组slab
2、每个slab下又有若干个page,每个page默认是1M,如果一个slab占用100M内存的话,那么这个slab下应该有100个page
3、每个page里面包含一组chunk,chunk是真正存放数据的地方,同一个slab里面的chunk的大小是固定的
4、有相同大小chunk的slab被组织在一起,称为slab_class
MemCache内存分配的方式称为allocator,slab的数量是有限的,几个、十几个或者几十个,这个和启动参数的配置相关。
MemCache中的value过来存放的地方是由value的大小决定的,value总是会被存放到与chunk大小最接近的一个slab中,比如slab[1]的chunk大小为80字节、slab[2]的chunk大小为100字节、slab[3]的chunk大小为128字节(相邻slab内的chunk基本以1.25为比例进行增长,MemCache启动时可以用-f指定这个比例),那么过来一个88字节的value,这个value将被放到2号slab中。放slab的时候,首先slab要申请内存,申请内存是以page为单位的,所以在放入第一个数据的时候,无论大小为多少,都会有1M大小的page被分配给该slab。申请到page后,slab会将这个page的内存按chunk的大小进行切分,这样就变成了一个chunk数组,最后从这个chunk数组中选择一个用于存储数据。
如果这个slab中没有chunk可以分配了怎么办,如果MemCache启动没有追加-M(禁止LRU,这种情况下内存不够会报Out Of Memory错误),那么MemCache会把这个slab中最近最少使用的chunk中的数据清理掉,然后放上最新的数据。针对MemCache的内存分配及回收算法,总结三点:
1、MemCache的内存分配chunk里面会有内存浪费,88字节的value分配在128字节(紧接着大的用)的chunk中,就损失了30字节,但是这也避免了管理内存碎片的问题
2、MemCache的LRU算法不是针对全局的,是针对slab的
3、应该可以理解为什么MemCache存放的value大小是限制的,因为一个新数据过来,slab会先以page为单位申请一块内存,申请的内存最多就只有1M,所以value大小自然不能大于1M了
再总结MemCache的特性和限制
上面已经对于MemCache做了一个比较详细的解读,这里再次总结MemCache的限制和特性:
1、MemCache中可以保存的item数据量是没有限制的,只要内存足够
2、MemCache单进程在32位机中最大使用内存为2G,这个之前的文章提了多次了,64位机则没有限制
3、Key最大为250个字节,超过该长度无法存储
4、单个item最大数据是1MB,超过1MB的数据不予存储
5、MemCache服务端是不安全的,比如已知某个MemCache节点,可以直接telnet过去,并通过flush_all让已经存在的键值对立即失效
6、不能够遍历MemCache中所有的item,因为这个操作的速度相对缓慢且会阻塞其他的操作
7、MemCache的高性能源自于两阶段哈希结构:第一阶段在客户端,通过Hash算法根据Key值算出一个节点;第二阶段在服务端,通过一个内部的Hash算法,查找真正的item并返回给客户端。从实现的角度看,MemCache是一个非阻塞的、基于事件的服务器程序
8、MemCache设置添加某一个Key值的时候,传入expiry为0表示这个Key值永久有效,这个Key值也会在30天之后失效,见memcache.c的源代码:
#define REALTIME_MAXDELTA 60*60*24*30 static rel_time_t realtime(const time_t exptime) { if (exptime == 0) return 0; if (exptime > REALTIME_MAXDELTA) { if (exptime <= process_started) return (rel_time_t)1; return (rel_time_t)(exptime - process_started); } else { return (rel_time_t)(exptime + current_time); } }
这个失效的时间是memcache源码里面写的,开发者没有办法改变MemCache的Key值失效时间为30天这个限制
【转】版权声明:https://github.com/wusuopubupt https://blog.csdn.net/wusuopuBUPT/article/details/18238003
1.为什么要使用memcache
由于网站的高并发读写需求,传统的关系型数据库开始出现瓶颈,例如:
1)对数据库的高并发读写:
关系型数据库本身就是个庞然大物,处理过程非常耗时(如解析SQL语句,事务处理等)。如果对关系型数据库进行高并发读写(每秒上万次的访问),那么它是无法承受的。
2)对海量数据的处理:
对于大型的SNS网站,每天有上千万次的数据产生(如twitter, 新浪微博)。对于关系型数据库,如果在一个有上亿条数据的数据表种查找某条记录,效率将非常低。
使用memcache能很好的解决以上问题。
在实际使用中,通常把数据库查询的结果保存到Memcache中,下次访问时直接从memcache中读取,而不再进行数据库查询操作,这样就在很大程度上减少了数据库的负担。
保存在memcache中的对象实际放置在内存中,这也是memcache如此高效的原因。
2.memcache的安装和使用
这个网上有太多教程了,不做赘言。
3.基于libevent的事件处理
libevent是个程序库,它将Linux的epoll、BSD类操作系统的kqueue等事件处理功能 封装成统一的接口。即使对服务器的连接数增加,也能发挥O(1)的性能。
memcached使用这个libevent库,因此能在Linux、BSD、Solaris等操作系统上发挥其高性能。
参考:
- libevent: http://www.monkey.org/~provos/libevent/
- The C10K Problem: http://www.kegel.com/c10k.html
4.memcache使用实例:
-
<?php
-
$mc = new Memcache();
-
$mc->connect('127.0.0.1', 11211);
-
$uid = (int)$_GET['uid'];
-
$sql = "select * from users where uid='uid' ";
-
$key = md5($sql);
-
if(!($data = $mc->get($key))) {
-
$conn = mysql_connect('localhost', 'test', 'test');
-
mysql_select_db('test');
-
$result = mysql_fetch_object($result);
-
while($row = mysql_fetch_object($result)) {
-
$data[] = $row;
-
}
-
$mc->add($key, $datas);
-
}
-
var_dump($datas);
-
?>
5.memcache如何支持高并发(此处还需深入研究)
memcache使用多路复用I/O模型,如(epoll, select等),传统I/O中,系统可能会因为某个用户连接还没做好I/O准备而一直等待,知道这个连接做好I/O准备。这时如果有其他用户连接到服务器,很可能会因为系统阻塞而得不到响应。
而多路复用I/O是一种消息通知模式,用户连接做好I/O准备后,系统会通知我们这个连接可以进行I/O操作,这样就不会阻塞在某个用户连接。因此,memcache才能支持高并发。
此外,memcache使用了多线程机制。可以同时处理多个请求。线程数一般设置为CPU核数,这研报告效率最高。
6.使用Slab分配算法保存数据
slab分配算法的原理是:把固定大小(1MB)的内存分为n小块,如下图所示:
slab分配算法把每1MB大小的内存称为一个slab页,每次向系统申请一个slab页,然后再通过分隔算法把这个slab页分割成若干个小块的chunk(如上图所示),然后把这些chunk分配给用户使用,分割算法如下(在slabs.c文件中):
(注:memcache的github项目地址:https://github.com/wusuopubupt/memcached)
-
/**
-
* Determines the chunk sizes and initializes the slab class descriptors
-
* accordingly.
-
*/
-
void slabs_init(const size_t limit, const double factor, const bool prealloc) {
-
int i = POWER_SMALLEST - 1;
-
unsigned int size = sizeof(item) + settings.chunk_size;
-
mem_limit = limit;
-
if (prealloc) {
-
/* Allocate everything in a big chunk with malloc 通过malloc的方式申请内存*/
-
mem_base = malloc(mem_limit);
-
if (mem_base != NULL) {
-
mem_current = mem_base;
-
mem_avail = mem_limit;
-
} else {
-
fprintf(stderr, "Warning: Failed to allocate requested memory in"
-
" one large chunk.\nWill allocate in smaller chunks\n");
-
}
-
}
-
memset(slabclass, 0, sizeof(slabclass));
-
while (++i < POWER_LARGEST && size <= settings.item_size_max / factor) {
-
/* Make sure items are always n-byte aligned 注意这里的字节对齐*/
-
if (size % CHUNK_ALIGN_BYTES)
-
size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES);
-
slabclass[i].size = size;
-
slabclass[i].perslab = settings.item_size_max / slabclass[i].size;
-
size *= factor;//以1.25为倍数增大chunk
-
if (settings.verbose > 1) {
-
fprintf(stderr, "slab class %3d: chunk size %9u perslab %7u\n",
-
i, slabclass[i].size, slabclass[i].perslab);
-
}
-
}
-
power_largest = i;
-
slabclass[power_largest].size = settings.item_size_max;
-
slabclass[power_largest].perslab = 1;
-
if (settings.verbose > 1) {
-
fprintf(stderr, "slab class %3d: chunk size %9u perslab %7u\n",
-
i, slabclass[i].size, slabclass[i].perslab);
-
}
-
/* for the test suite: faking of how much we've already malloc'd */
-
{
-
char *t_initial_malloc = getenv("T_MEMD_INITIAL_MALLOC");
-
if (t_initial_malloc) {
-
mem_malloced = (size_t)atol(t_initial_malloc);
-
}
-
}
-
if (prealloc) {
-
slabs_preallocate(power_largest);
-
}
-
}
上面代码中的slabclass是一个类型为slabclass_t结构的数组,其定义如下:
-
typedef struct {
-
unsigned int size; /* sizes of items */
-
unsigned int perslab; /* how many items per slab */
-
void **slots; /* list of item ptrs */
-
unsigned int sl_total; /* size of previous array */
-
unsigned int sl_curr; /* first free slot */
-
void *end_page_ptr; /* pointer to next free item at end of page, or 0 */
-
unsigned int end_page_free; /* number of items remaining at end of last alloced page */
-
unsigned int slabs; /* how many slabs were allocated for this class */
-
void **slab_list; /* array of slab pointers */
-
unsigned int list_size; /* size of prev array */
-
unsigned int killing; /* index+1 of dying slab, or zero if none */
-
size_t requested; /* The number of requested bytes */
-
} slabclass_t;
借用别人的一张图说明slabclass_t结构:
由分割算法的源代码可知,slab算法按照不同大小的chunk分割slab页,而不同大小的chunk以factor(默认是1.25)倍增大。
使用memcache -u root -vv 命令查看内存分配情况(8字节对齐):
找到大小最合适的chunk分配给请求缓存的数据:
-
/*
-
* Figures out which slab class (chunk size) is required to store an item of
-
* a given size.
-
*
-
* Given object size, return id to use when allocating/freeing memory for object
-
* 0 means error: can't store such a large object
-
*/
-
unsigned int slabs_clsid(const size_t size) {
-
int res = POWER_SMALLEST;// 初始化为最小的chunk
-
if (size == 0)
-
return 0;
-
while (size > slabclass[res].size) //逐渐增大chunk size,直到找到第一个比申请的size大的chunk
-
if (res++ == power_largest) /* won't fit in the biggest slab */
-
return 0;
-
return res;
-
}
内存分配:
(此处参考:http://slowsnail.com.cn/?p=20)
-
static void *do_slabs_alloc(const size_t size, unsigned int id) {
-
slabclass_t *p;
-
void *ret = NULL;
-
item *it = NULL;
-
if (id < POWER_SMALLEST || id > power_largest) {//判断id是否会导致slabclass[]数组越界
-
MEMCACHED_SLABS_ALLOCATE_FAILED(size, 0);
-
return NULL;
-
}
-
p = &slabclass[id];//获取slabclass[id]的引用
-
assert(p->sl_curr == 0 || ((item *)p->slots)->slabs_clsid == 0);//判断slabclass[id]是否有剩余的chunk
-
if (! (p->sl_curr != 0 || do_slabs_newslab(id) != 0)) {//如果slabclass[id]中已经没有空余chunk并且试图向系统申请一个“页”(slab)的chunk失败,则返回NULL
-
/* We don't have more memory available */
-
ret = NULL;
-
} else if (p->sl_curr != 0) {//slabclass[id]的空闲链表中还有chunk,则直接将其分配出去
-
it = (item *)p->slots;//获取空闲链表的头指针
-
p->slots = it->next;//将头结点指向下一个结点(取下头结点)
-
if (it->next) it->next->prev = 0;//将新头结点的prev指针置空
-
p->sl_curr--;//减少slabclass[id]空闲链表中的chunk计数
-
ret = (void *)it;//将头结点赋给ret指针
-
}
-
if (ret) {//请求成功
-
p->requested += size;//更新slabclass[id]所分配的内存总数
-
MEMCACHED_SLABS_ALLOCATE(size, id, p->size, ret);
-
} else {
-
MEMCACHED_SLABS_ALLOCATE_FAILED(size, id);
-
}
-
return ret;
-
}
do_slabs_allc()函数首先尝试从slot列表(被回收的chunk)中获取可用的chunk,如果有可用的就返回,否则从空闲的chunk列表中获取可用的chunk并返回。
删除过期item:
延迟删除过期item到查找时进行,可以提高memcache的效率,因为不必每时每刻检查过期item,从而提高CPU工作效率
使用LRU(last recently used)算法淘汰数据:
-
/*
-
* try to get one off the right LRU
-
* don't necessariuly unlink the tail because it may be locked: refcount>0
-
* search up from tail an item with refcount==0 and unlink it; give up after 50
-
* tries
-
*/
-
if (tails[id] == 0) {
-
itemstats[id].outofmemory++;
-
return NULL;
-
}
-
for (search = tails[id]; tries > 0 && search != NULL; tries--, search=search->prev) {
-
if (search->refcount == 0) { //refount==0的情况,释放掉
-
if (search->exptime == 0 || search->exptime > current_time) {
-
itemstats[id].evicted++;
-
itemstats[id].evicted_time = current_time - search->time;
-
STATS_LOCK();
-
stats.evictions++;
-
STATS_UNLOCK();
-
}
-
do_item_unlink(search);
-
break;
-
}
-
}
-
it = slabs_alloc(ntotal, id);
-
if (it == 0) {
-
itemstats[id].outofmemory++;
-
/* Last ditch effort. There is a very rare bug which causes
-
* refcount leaks. We've fixed most of them, but it still happens,
-
* and it may happen in the future.
-
* We can reasonably assume no item can stay locked for more than
-
* three hours, so if we find one in the tail which is that old,
-
* free it anyway.
-
*/
-
tries = 50;
-
for (search = tails[id]; tries > 0 && search != NULL; tries--, search=search->prev) {
-
if (search->refcount != 0 && search->time + 10800 < current_time) { //最近3小时没有被访问到的情况,释放掉
-
itemstats[id].tailrepairs++;
-
search->refcount = 0;
-
do_item_unlink(search);
-
break;
-
}
-
}
-
it = slabs_alloc(ntotal, id);
-
if (it == 0) {
-
return NULL;
-
}
-
}
从item列表的尾部开始遍历,找到refcount==0的chunk,调用do_item_unlink()函数释放掉,另外,search->time+10800<current_time(即最近3小时没有被访问过的item),也释放掉--这就是LRU算法的原理。
附:阿里2014笔试题一道:
某缓存系统采用LRU淘汰算法,假定缓存容量为4,并且初始为空,那么在顺序访问一下数据项的时候:1,5,1,3,5,2,4,1,2出现缓存直接命中的次数是?,最后缓存中即将准备淘汰的数据项是?
答案:3, 5
解答:
- 1调入内存 1
- 5调入内存 1 5
- 1调入内存 5 1(命中 1,更新次序)
- 3调入内存 5 1 3
- 5调入内存 1 3 5 (命中5)
- 2调入内存 1 3 5 2
- 4调入内存(1最久未使用,淘汰1) 3 5 2 4
- 1调入内存(3最久未使用,淘汰3) 5 2 4 1
- 2调入内存 5 4 1 2(命中2)
因此,直接命中次数是3,最后缓存即将准备淘汰的数据项是5
--------------------- 本文来自 d4shman 的CSDN 博客 ,全文地址请点击:https://blog.csdn.net/wusuopuBUPT/article/details/18238003?utm_source=copy