memcached（三）内存管理
memcached使用预申请的方式来管理内存的分配，从而避免内存碎片化的问题。如果采用mallo和free来动态的申请和销毁内存，必然会产生大量的内存碎片。
slab：内存块是memcached一次申请内存的最小单元，在memcached中一个slab的默认大小为1M；
slabclass：特定大小的chunk的组。
chunk：缓存的内存空间，一个slab被划分为若干个chunk；
item：存储数据的最小单元，每一个chunk都会包含一个item；
factor:增长因子，默认为1.25，相邻slab中的item大小与factor成比例关系；
memcached使用预分配方法，避免频繁的调用malloc和free；
memcached通过不同的slab来管理不同chunk大小的内存块，从而满足存储不同大小的数据。
slab的申请是通过在使用item时申请slab大小的内存空间，然后再把内存切割为大小相同的item，挂在到slab的未使用链表上。
过期和被删除item并不会被free掉，memcached并不会删除已经分配的内存；
Memcached会优先使用已超时的记录空间，通过LRU算法；
memcached使用lazy expiration来判断元素是否过期，所以过期监视上不会占用cpu时间。
下面主要分析memcached的内存申请和存储相关代码。
item是key/value的存储单元。
typedef struct _stritem {
struct _stritem *
/* 前后指针用于在链表slab-&slots中连接前后数据 */
struct _stritem *
struct _stritem *h_
/* hash chain next */
/* 最后一次访问时间 */
/* 过期时间 */
/* 数据大小 */
unsigned short
/* 引用次数 */
/* suffix长度 */
/* ITEM_* above */
slabs_/* 所有slab的id */
/* key长度 */
/* this odd type prevents type-punning issues when we do
* the little shuffle to save space when not using CAS. */
} data[]; /* cas|key|suffix|value */
slab初始化
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_ /* 得到每一个item的大小 */
mem_limit =
if (prealloc) { /* 预分配一块内存 */
memset(slabclass, 0, sizeof(slabclass)); /* 把slabclass置为0，slabclass是一个slab数组，存储所有slab的信息 */
while (++i & POWER_LARGEST && size &= settings.item_size_max / factor) {
/* 循环初始化每一个slab的内容,保证slab中item的size小于max_size/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 = /* 初始化slabclass中item的大小 */
slabclass[i].perslab = settings.item_size_max / slabclass[i]. /* 初始化每个slab中item的数量 */
/* item的大小随factor逐渐增大 */
/* 初始化最后一个slab,大小为最大的max_size，只有一个item */
power_largest =
slabclass[power_largest].size = settings.item_size_
slabclass[power_largest].perslab = 1;
从源码中，可以看出来同一个slab中所有的item的大小都是固定的，
申请slab内存
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是否合法 */
MEMCACHED_SLABS_ALLOCATE_FAILED(size, 0);
return NULL;
p = &slabclass[id]; /* 获取slab */
assert(p-&sl_curr == 0 || ((item *)p-&slots)-&slabs_clsid == 0);
/* fail unless we have space at the end of a recently allocated page,
we have something on our freelist, or we could allocate a new page */
if (! (p-&sl_curr != 0 || do_slabs_newslab(id) != 0)) { /*如果sl_curr为0，没有剩余的item，那么就执行do_slabs_newslab申请内存空间*/
/* We don't have more memory available */
ret = NULL;
} else if (p-&sl_curr != 0) { /* 如果有未使用的空间，则获取该item，并从slots链表中删除该item */
/* return off our freelist */
it = (item *)p-&
p-&slots = it-&
if (it-&next) it-&next-&prev = 0;
p-&sl_curr--;
ret = (void *)
sl_curr来判断是否存在未使用的内容空间，如果不存在需要调用do_slabs_newslab来申请slab空间。
static int do_slabs_newslab(const unsigned int id) {
slabclass_t *p = &slabclass[id];
int len = settings.slab_reassign ? settings.item_size_max
: p-&size * p-&
/* 1. 判断是否超过内存限制
2. 判断是否申请过内存空间
3. 如果没有申请过，则申请slab-&size*slab-&perslab大小的整块内存
4.如果申请过，调用grow_slab_list来扩大slab大小 */
if ((mem_limit && mem_malloced + len & mem_limit && p-&slabs & 0) ||
(grow_slab_list(id) == 0) ||
((ptr = memory_allocate((size_t)len)) == 0)) {
MEMCACHED_SLABS_SLABCLASS_ALLOCATE_FAILED(id);
memset(ptr, 0, (size_t)len);
split_slab_page_into_freelist(ptr, id); /* 把申请的内存分配到slots链表中 */
p-&slab_list[p-&slabs++] =
mem_malloced +=
MEMCACHED_SLABS_SLABCLASS_ALLOCATE(id);
申请空间后，需要通过split_slab_page_into_freelist函数把申请的内存空间分配到未使用的链表中。
static void split_slab_page_into_freelist(char *ptr, const unsigned int id) {
slabclass_t *p = &slabclass[id];
for (x = 0; x & p-& x++) { /* 循环分配内存 */
do_slabs_free(ptr, 0, id);
ptr += p-&
static void do_slabs_free(void *ptr, const size_t size, unsigned int id) {
slabclass_t *p;
p = &slabclass[id];
/* 获取内存指针，把item块挂在到slots链表中，增加sl_curr */
it = (item *)
it-&it_flags |= ITEM_SLABBED;
it-&prev = 0;
it-&next = p-&
if (it-&next) it-&next-&prev =
p-&slots =
p-&sl_curr++;
p-&requested -=
获取适当大小的item
在do_item_alloc中，调用了slabs_clsid来获取适合存储当前元素的slab id。
unsigned int slabs_clsid(const size_t size) {
int res = POWER_SMALLEST;
if (size == 0)
while (size & slabclass[res].size)
/* 遍历slabclass来找到适合size的item */
if (res++ == power_largest)
/* won't fit in the biggest slab */
内存预分配可以避免内存碎片以及避免动态分配造成的开销。
内存分配是由冗余的，当一个slab不能被它所拥有的chunk大小整除时，slab尾部剩余的空间就会被丢弃。
由于分配的是特定长度的内存，因此无法有效地利用所有分配的内存，例如如果将100字节的数据存储在128字节的chunk中，会造成28字节的浪费。
阅读(...) 评论()[转载]memcache&丢失数据问题
&今天突然发现memcache里的数据部分会丢失，我是批量插入2000+个数据，程序在运行时插入的第一个数据有值，但是程序运行完毕，第一个数据就没值了，后经过检查发现，memcache分配的内存默认为64M，满了之后会自动删除部分未过期的数据，导致上述情况。后调整为2G，问题解决。特记下memcache中stats查看的数据含义：
php中查看代码：
3&&&&&$host&=&$_REQUEST['host'];
5&&&&&$mem&=&new&Memcache;
6&&&&&$mem-&connect&(&$host,&11211&);&
7&&&&&print_r&(&$mem-&getStats()
或者连上memcache，然后stats，详细如下：
mqq@32_167_game:~& telnet server port
Trying 172.16.32.166...
Connected to 172.16.32.166.
Escape character is '^]'.
STAT pid 26530
STAT uptime 5807
STAT version 1.2.2
STAT pointer_size 64
STAT rusage_user 12.372773
STAT rusage_system 24.233514
STAT curr_items 72820
STAT total_items 5526
STAT bytes
STAT curr_connections 115
STAT total_connections 1
STAT connection_structures 116
STAT cmd_get 12507
STAT cmd_set 5526
STAT get_hits 12498
STAT get_misses 9
STAT evictions 0
STAT bytes_read 7363968
STAT bytes_written
STAT limit_maxbytes
STAT threads 1
memcache服务器的进程ID
服务器已经运行的秒数
服务器当前的unix时间戳
memcache版本
pointer_size
当前OS的指针大小（32位系统一般是32bit）
rusage_user
进程的累计用户时间
rusage_system
进程的累计系统时间
curr_items
服务器当前存储的items数量
total_items
从服务器启动以后存储的items总数量
当前服务器存储items占用的字节数
curr_connections
当前打开着的连接数
total_connections
从服务器启动以后曾经打开过的连接数
connection_structures
服务器分配的连接构造数
get命令（获取）总请求次数
set命令（保存）总请求次数
总命中次数
get_misses
总未命中次数
为获取空闲内存而删除的items数（分配给memcache的空间用满后需要删除旧的items来得到空间分配给新的items）
bytes_read
总读取字节数（请求字节数）
bytes_written
总发送字节数（结果字节数）
limit_maxbytes
分配给memcache的内存大小（字节）
当前线程数
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。1522人阅读
运营安全（2）
Memcache安全配置
memcached -d -m 100 -u root -l x.x.x.x -p 11211 -c 512 -P /tmp/memcached.pid
参数说明：
-d选项是启动一个守护进程；
-m是分配给Memcache使用的内存数量，单位是MB，我这里是100MB；
-u是运行Memcache的用户，我这里是root；
-l是监听的服务器IP地址我这里指定了服务器的IP地址x.x.x.x；
-p是设置Memcache监听的端口，我这里设置了11211，最好是1024以上的端口；
-c选项是最大运行的并发连接数，默认是1024，我这里设置了512，按照你服务器的负载量来设定；
-P是设置保存Memcache的pid文件，我这里是保存在 /tmp/memcached.pid；
管理工具：
phpMemcachedAdmin图形化界面，操作memcache，类似phpmyadmin
&Memcache是一个高性能的分布式的内存对象缓存系统，
通过在内存里维护一个统一的巨大的hash表，
它能够用来存储各种格式的数据，包括图像、
视频、文件以及数据库检索的结果等。
内存对象缓存系统：数据–&内存–&读取
简单的说就是将数据调用到内存中，然后从内存中读取，
从而大大提高读取速度。
1、Memcache服务器端都是直接通过客户端连接后直接操作，没有任何的验证过程。没有任何的验证过程，这样如果服务器是直接暴露在互联网上的话是比较危险，轻则数据泄露被其他无关人员查看，重则服务器被入侵。
2、Mecache是以root权限运行的，况且里面可能存在一些我们未知的bug或者是缓冲区溢出的情况，这些都是我们未知的，所以危险性是可以预见的。
&memcache匿名访问危害
&查找可匿名访问memcache的方式
&&memcache默认是11211端口，
可使用nmap扫描有开11211端口的服务器。
nmap -n –open -p 11211 X.X.X.X/24
telnet上，执行下stats items看看是否有返回结果。
&从memcache中获取信息通常是先查看items信息
stats items
stats cachedump &item: id& &返回结果数量,0代表返回全部&
管理工具：phpMemcachedAdmin
&限制访问地址
最好把两台服务器之间的访问是内网形态的，一般是Web服务器跟Memcache服务器之间。普遍的服务器都是有两块网卡，一块指向互联网，一块指向内网，那么就让Web服务器通过内网的网卡来访问Memcache服务器，我们Memcache的服务器上启动的时候就监听内网的IP地址和端口，内网间的访问能够有效阻止其他非法的访问。
# memcached -d -m 1024 -u root -l 192.168.0.200 -p 11211 -c 1024 -P /tmp/memcached.pid
Memcache服务器端设置监听通过内网的192.168.0.200的ip的11211端口，占用1024MB内存，并且允许最大1024个并发连接
设置防火墙
防火墙是简单有效的方式，如果却是两台服务器都是挂在网的，并且需要通过外网IP来访问Memcache的话，那么可以考虑使用防火墙或者代理程序来过滤非法访问。 一般我们在Linux下可以使用iptables或者FreeBSD下的ipfw来指定一些规则防止一些非法的访问，比如我们可以设置只允许我们的Web服务器来访问我们Memcache服务器，同时阻止其他的访问。
# iptables -F
# iptables -P INPUT DROP
# iptables -A INPUT -p tcp -s 192.168.0.2 –dport 11211 -j ACCEPT
# iptables -A INPUT -p udp -s 192.168.0.2 –dport 11211 -j ACCEPT
上面的iptables规则就是只允许192.168.0.2这台Web服务器对Memcache服务器的访问，能够有效的阻止一些非法访问，相应的也可以增加一些其他的规则来加强安全性，这个可以根据自己的需要来做。
&&内网访问
&&防火墙限制端口
思维导图：
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：64548次
排名：千里之外ehcache memcache - 我的异常网当前位置:& &&&ehcache memcacheehcache memcache&&网友分享于：&&&搜索量：48次
场景：ehcache memcache redis 差别ehcache memcache redis 差异
转自：http://blog.csdn.net/jationxiaozi/article/details/8509732
在java项目广泛的使用。它是一个开源的、设计于提高在数据从RDBMS中取出来的高花费、高延迟采取的一种缓存方案。正因为Ehcache具有健壮性（基于java开发）、被认证（具有apache 2.0
license）、充满特色（稍后会详细介绍），所以被用于大型复杂分布式web application的各个节点中。
什么特色？
Ehcache的发行有一段时长了，经过几年的努力和不计其数的性能测试，Ehcache终被设计于large, high concurrency systems.
开发者提供的接口非常简单明了，从Ehcache的搭建到运用运行仅仅需要的是你宝贵的几分钟。其实很多开发者都不知道自己用在用Ehcache，Ehcache被广泛的运用于其他的开源项目
比如：hibernate
关于这点的特性，官方给了一个很可爱的名字small foot print ，一般Ehcache的发布版本不会到2M，V 2.2.3
才 668KB。
核心程序仅仅依赖slf4j这一个包，没有之一！
Ehcache提供了对大数据的内存和硬盘的存储，最近版本允许多实例、保存对象高灵活性、提供LRU、LFU、FIFO淘汰算法，基础属性支持热配置、支持的插件多
缓存管理器监听器 （CacheManagerListener）和 缓存监听器（CacheEvenListener）,做一些统计或数据一致性广播挺好用的
如何使用？
够简单就是Ehcache的一大特色，自然用起来just so easy!
贴一段基本使用代码
CacheManager manager = CacheManager.newInstance("src/config/ehcache.xml");
Ehcache cache = new Cache("testCache", 5000, false, false, 5, 2);
cacheManager.addCache(cache);
代码中有个ehcache.xml文件，现在来介绍一下这个文件中的一些属性
name:缓存名称。
maxElementsInMemory：缓存最大个数。
eternal:对象是否永久有效，一但设置了，timeout将不起作用。
timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
timeToLiveSeconds：设置对象在失效前允许存活时间,最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时 间无穷大。
overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
maxElementsOnDisk：硬盘最大缓存个数。
diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU。你可以设置为 FIFO或是LFU。
clearOnFlush：内存数量最大时是否清除。
memcache 是一种高性能、分布式对象缓存系统，最初设计于缓解动态网站数据库加载数据的延迟性，你可以把它想象成一个大的内存HashTable，就是一个key-value键值缓存。Danga Interactive为了LiveJournal所发展的，以BSD license释放的一套开放源代码软件。
memcache C语言所编写，依赖于最近版本的GCC和libevent。GCC是它的编译器，同事基于libevent做socket io。在安装memcache时保证你的系统同事具备有这两个环境。
2.多线程支持
memcache支持多个cpu同时工作，在memcache安装文件下有个叫threads.txt中特别说明，By default, memcached is compiled as a single-threaded application.默认是单线程编译安装，如果你需要多线程则需要修改./configure --enable-threads，为了支持多核系统，前提是你的系统必须具有多线程工作模式。开启多线程工作的线程数默认是4，如果线程数超过cpu数容易发生操作死锁的概率。结合自己业务模式选择才能做到物尽其用。
通过libevent完成socket 的通讯，理论上性能的瓶颈落在网卡上。
简单安装：
1.分别把memcached和libevent下载回来，放到 /tmp 目录下：
# wget /memcached/dist/memcached-1.2.0.tar.gz
# wget http://www.monkey.org/~provos/libevent-1.2.tar.gz
2.先安装libevent：
# tar zxvf libevent-1.2.tar.gz
# cd libevent-1.2
# ./configure -prefix=/usr
# make （如果遇到提示gcc 没有安装则先安装gcc)
# make install
3.测试libevent是否安装成功：
# ls -al /usr/lib | grep libevent
lrwxrwxrwx 1 root root 21 11?? 12 17:38 libevent-1.2.so.1 -& libevent-1.2.so.1.0.3
-rwxr-xr-x 1 root root ?? 12 17:38 libevent-1.2.so.1.0.3
-rw-r-r- 1 root root ?? 12 17:38 libevent.a
-rwxr-xr-x 1 root root 811 11?? 12 17:38 libevent.la
lrwxrwxrwx 1 root root 21 11?? 12 17:38 libevent.so -& libevent-1.2.so.1.0.3
还不错，都安装上了。
4.安装memcached，同时需要安装中指定libevent的安装位置：
# tar zxvf memcached-1.2.0.tar.gz
# cd memcached-1.2.0
# ./configure -with-libevent=/usr
# make install
如果中间出现报错，请仔细检查错误信息，按照错误信息来配置或者增加相应的库或者路径。
安装完成后会把memcached放到 /usr/local/bin/memcached ，
5.测试是否成功安装memcached：
# ls -al /usr/local/bin/mem*
-rwxr-xr-x 1 root root ?? 12 17:39 /usr/local/bin/memcached
-rwxr-xr-x 1 root root ?? 12 17:39 /usr/local/bin/memcached-debug
启动memcache服务
启动Memcached服务：
1.启动Memcache的服务器端：
# /usr/local/bin/memcached -d -m 8096 -u root -l 192.168.77.105 -p 12000 -c 256 -P /tmp/memcached.pid
-d选项是启动一个守护进程，
-m是分配给Memcache使用的内存数量，单位是MB，我这里是8096MB，
-u是运行Memcache的用户，我这里是root，
-l是监听的服务器IP地址，如果有多个地址的话，我这里指定了服务器的IP地址192.168.77.105，
-p是设置Memcache监听的端口，我这里设置了12000，最好是1024以上的端口，
-c选项是最大运行的并发连接数，默认是1024，我这里设置了256，按照你服务器的负载量来设定，
-P是设置保存Memcache的pid文件，我这里是保存在 /tmp/memcached.pid，
2.如果要结束Memcache进程，执行：
# cat /tmp/memcached.pid 或者 ps -aux | grep memcache
（找到对应的进程id号）
# kill 进程id号
也可以启动多个守护进程，不过端口不能重复。
memcache 的连接
注意连接之前需要再memcache服务端把memcache的防火墙规则加上
-A RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 3306 -j ACCEPT
重新加载防火墙规则
service iptables restart
OK ,现在应该就可以连上memcache了
在客户端输入stats 查看memcache的状态信息
memcache服务器的进程ID
服务器已经运行的秒数
服务器当前的unix时间戳
memcache版本
pointer_size
当前操作系统的指针大小（32位系统一般是32bit）
rusage_user
进程的累计用户时间
rusage_system
进程的累计系统时间
curr_items
服务器当前存储的items数量
total_items
从服务器启动以后存储的items总数量
当前服务器存储items占用的字节数
curr_connections
当前打开着的连接数
total_connections
从服务器启动以后曾经打开过的连接数
connection_structures
服务器分配的连接构造数
cmd_get get命令
（获取）总请求次数
cmd_set set命令
（保存）总请求次数
总命中次数
get_misses
总未命中次数
为获取空闲内存而删除的items数（分配给memcache的空间用满后需要删除旧的items来得到空间分配给新的items）
bytes_read
读取字节数（请求字节数）
bytes_written
总发送字节数（结果字节数）
limit_maxbytes
分配给memcache的内存大小（字节）
当前线程数
redis是在memcache之后编写的，大家经常把这两者做比较，如果说它是个key-value store 的话但是它具有丰富的数据类型，我想暂时把它叫做缓存数据流中心，就像现在物流中心那样，order、package、store、classification、distribute、end。现在还很流行的LAMP PHP架构 不知道和 redis+mysql 或者 redis + mongodb的性能比较（听群里的人说mongodb分片不稳定）。
先说说reidis的特性
1. 支持持久化
redis的本地持久化支持两种方式：RDB和AOF。RDB 在redis.conf配置文件里配置持久化触发器，AOF指的是redis没增加一条记录都会保存到持久化文件中（保存的是这条记录的生成命令），如果不是用redis做DB用的话还会不要开AOF ，数据太庞大了，重启恢复的时候是一个巨大的工程！
2.丰富的数据类型
redis 支持 String 、Lists、sets、sorted sets、hashes 多种数据类型,新浪微博会使用redis做nosql主要也是它具有这些类型，时间排序、职能排序、我的微博、发给我的这些功能List 和 sorted set
的强大操作功能息息相关
这点跟memcache很想象，内存操作的级别是毫秒级的比硬盘操作秒级操作自然高效不少，较少了磁头寻道、数据读取、页面交换这些高开销的操作！这也是NOSQL冒出来的原因吧，应该是高性能
是基于RDBMS的衍生产品，虽然RDBMS也具有缓存结构，但是始终在app层面不是我们想要的那么操控的。
4.replication
redis提供主从复制方案，跟mysql一样增量复制而且复制的实现都很相似，这个复制跟AOF有点类似复制的是新增记录命令，主库新增记录将新增脚本发送给从库，从库根据脚本生成记录，这个过程非常快，就看网络了，一般主从都是在同一个局域网，所以可以说redis的主从近似及时同步，同事它还支持一主多从，动态添加从库，从库数量没有限制。 主从库搭建，我觉得还是采用网状模式，如果使用链式（master-slave-slave-slave-slave·····）如果第一个slave出现宕机重启，首先从master 接收 数据恢复脚本，这个是阻塞的，如果主库数据几TB的情况恢复过程得花上一段时间，在这个过程中其他的slave就无法和主库同步了。
这点好像从我接触到redis到目前为止 已经发了大版本就4个，小版本没算过。redis作者是个非常积极的人，无论是邮件提问还是论坛发帖，他都能及时耐心的为你解答，维护度很高。有人维护的话，让我们用的也省心和放心。目前作者对redis 的主导开发方向是redis的集群方向。
redis的安装
redis的安装其实还是挺简单的，总的来说就三步：下载tar包，解压tar包，安装。
不过最近我在2.6.7后用centos 5.5 32bit 时碰到一个安装问题，下面我就用图片分享下安装过程碰到的问题，在redis 文件夹内执行make时有个如下的错 undefined reference to '__sync_add_and_fetch_4'
上网找了了好多最后在
/antirez/redis/issues/736 找到解决方案，write CFLAGS= -march=i686 on src/Makefile head!
记得要把刚安装失败的文件删除，重新解压新的安装文件，修改Makefile文件，再make安装。就不会发现原来那个错误了
关于redis的一些属性注释和基本类型操作在上一篇redis 的开胃菜有详细的说明，这里就不再重复累赘了（实质是想偷懒 ，哈哈！）
最后，把memcache和redis放在一起不得不会让人想到两者的比较，谁快谁好用啊，群里面已经为这个事打架很久了，我就把我看到的在这里跟大家分享下。
在别人发了一个memcache性能比redis好很多后，redis 作者 antirez 发表了一篇博文，主要是说到如何给redis 和 memcache 做压力测试，文中讲到有个人说许多开源软件都应该丢进厕所，因为他们的压力测试脚本太2了，作者对这个说明了一番。redis
memcache is
definitely an apple to apple comparison。 呵呵，很明确吧，两者的比较是不是有点鸡蛋挑骨头的效果，作者在相同的运行环境做了三次测试取多好的值，得到的结果如下图:
需要申明的是此次测试在单核心处理的过程的数据，memcache是支持多核心多线程操作的（默认没开）所以在默认情况下上图具有参考意义，若然则memcache快于redis。那为什么redis不支持多线程多核心处理呢？作者也发表了一下自己的看法，首先是多线程不变于bug的修复，其实是不易软件的扩展，还有数据一致性问题因为redis所有的操作都是原子操作，作者用到一个词nightmare 噩梦，呵呵！
当然不支持多线程操作，肯定也有他的弊端的比如性能想必必然差，作者从2.2版本后专注redis cluster的方向开发来缓解其性能上的弊端，说白了就是纵向不行，横向提高。
12345678910
12345678910
12345678910 上一篇：下一篇：文章评论相关文章 12345678910 Copyright & &&版权所有