Memcache工作原理及安装使用

Memcache工作原

1       Memcache是什么

Memcache是danga.com的一个项目，最早是为 LiveJournal 服务的，目前全世界不少人使用这个缓存项目来构建自己大负载的网站，来分担数据库的压力。

它可以应对任意多个连接，使用非阻塞的网络IO。由于它的工作机制是在内存中开辟一块空间，然后建立一个HashTable，Memcached自管理这些HashTable。

为什么会有Memcache和memcached两种名称？

其实Memcache是这个项目的名称，而memcached是它服务器端的主程序文件名，

Memcache官方网站：http://www.danga.com/memcached，

2     面临的问题

对于高并发高访问的Web应用程序来说，数据库存取瓶颈一直是个令人头疼的问题。特别当你的程序架构还是建立在单数据库模式，而一个数据池连接数峰 值已经达到500的时候，那你的程序运行离崩溃的边缘也不远了。很多小网站的开发人员一开始都将注意力放在了产品需求设计上，缺忽视了程序整体性能，可扩 展性等方面的考虑，结果眼看着访问量一天天网上爬，可突然发现有一天网站因为访问量过大而崩溃了，到时候哭都来不及。所以我们一定要未雨绸缪，在数据库还 没罢工前，想方设法给它减负，这也是这篇文章的主要议题。

大家都知道，当有一个request过来后，web服务器交给app服务器，app处理并从db中存取相关数据，但db存取的花费是相当高昂的。特 别是每次都取相同的数据，等于是让数据库每次都在做高耗费的无用功，数据库如果会说话，肯定会发牢骚，你都问了这么多遍了，难道还记不住吗？是啊，如果 app拿到第一次数据并存到内存里，下次读取时直接从内存里读取，而不用麻烦数据库，这样不就给数据库减负了？而且从内存取数据必然要比从数据库媒介取快 很多倍，反而提升了应用程序的性能。

因此，我们可以在web/app层与db层之间加一层cache层，主要目的：1. 减少数据库读取负担；2. 提高数据读取速度。而且，cache存取的媒介是内存，而一台服务器的内存容量一般都是有限制的，不像硬盘容量可以做到TB级别。所以，可以考虑采用分布 式的cache层，这样更易于破除内存容量的限制，同时又增加了灵活性。

3      Memcache工作原理

首先 memcached 是以守护程序方式运行于一个或多个服务器中，随时接受客户端的连接操作，客户端可以由各种语言编写，目前已知的客户端 API 包括 Perl/PHP/Python/Ruby/Java/C#/C 等等。客户端在与 memcached 服务建立连接之后，接下来的事情就是存取对象了，每个被存取的对象都有一个唯一的标识符 key，存取操作均通过这个 key 进行，保存到 memcached 中的对象实际上是放置内存中的，并不是保存在 cache 文件中的，这也是为什么 memcached 能够如此高效快速的原因。注意，这些对象并不是持久的，服务停止之后，里边的数据就会丢失。

与许多 cache 工具类似，Memcached 的原理并不复杂。它采用了C/S的模式，在 server 端启动服务进程，在启动时可以指定监听的 ip，自己的端口号，所使用的内存大小等几个关键参数。一旦启动，服务就一直处于可用状态。Memcached 的目前版本是通过C实现，采用了单进程，单线程，异步I/O，基于事件 (event_based) 的服务方式.使用 libevent 作为事件通知实现。多个 Server 可以协同工作，但这些 Server 之间是没有任何通讯联系的，每个 Server 只是对自己的数据进行管理。Client 端通过指定 Server 端的 ip 地址(通过域名应该也可以)。需要缓存的对象或数据是以 key->value 对的形式保存在Server端。key 的值通过 hash 进行转换，根据 hash 值把 value 传递到对应的具体的某个 Server 上。当需要获取对象数据时，也根据 key 进行。首先对 key 进行 hash，通过获得的值可以确定它被保存在了哪台 Server 上，然后再向该 Server 发出请求。Client 端只需要知道保存 hash(key) 的值在哪台服务器上就可以了。

       其实说到底，memcache 的工作就是在专门的机器的内存里维护一张巨大的 hash 表，来存储经常被读写的一些数组与文件，从而极大的提高网站的运行效率。

Memcached 介绍

Memcached是开源的分布式cache系统，现在很多的大型web应用程序包括 facebook，youtube，wikipedia，yahoo等等都在使用memcached来支持他们每天数亿级的页面访问。通过把cache层 与他们的web架构集成，他们的应用程序在提高了性能的同时，还大大降低了数据库的负载。 具体的memcached资料大家可以直接从它的官方网站[1]上得到。这里我就简单给大家介绍一下memcached的工作原理：

Memcached处理的原子是每一个（key，value）对（以下简称kv对），key会通过一个hash算法转化成hash-key，便于查找、对比以及做到尽可能的散列。同时，memcached用的是一个二级散列，通过一张大hash表来维护。

Memcached有两个核心组件组成：服务端（ms）和客户端（mc），在一个memcached的查询中，mc先通过计算key的hash值来 确定kv对所处在的ms位置。当ms确定后，客户端就会发送一个查询请求给对应的ms，让它来查找确切的数据。因为这之间没有交互以及多播协议，所以 memcached交互带给网络的影响是最小化的。

举例说明：考虑以下这个场景，有三个mc分别是X，Y，Z，还有三个ms分别是A，B，C：

设置kv对 X想设置key=”foo”,value=”seattle” X拿到ms列表，并对key做hash转化，根据hash值确定kv对所存的ms位置 B被选中了 X连接上B，B收到请求，把（key=”foo”,value=”seattle”）存了起来

获取kv对 Z想得到key=”foo”的value Z用相同的hash算法算出hash值，并确定key=”foo”的值存在B上 Z连接上B，并从B那边得到value=”seattle” 其他任何从X，Y，Z的想得到key=”foo”的值的请求都会发向B

Memcached服务器(ms)

内存分配

默认情况下，ms是用一个内置的叫“块分配器”的组件来分配内存的。舍弃c++标准的malloc/free的内存分配，而采用块分配器的主要目的 是为了避免内存碎片，否则操作系统要花费更多时间来查找这些逻辑上连续的内存块（实际上是断开的）。用了块分配器，ms会轮流的对内存进行大块的分配，并 不断重用。当然由于块的大小各不相同，当数据大小和块大小不太相符的情况下，还是有可能导致内存的浪费。

同时，ms对key和data都有相应的限制，key的长度不能超过250字节，data也不能超过块大小的限制 --- 1MB。 因为mc所使用的hash算法，并不会考虑到每个ms的内存大小。理论上mc会分配概率上等量的kv对给每个ms，这样如果每个ms的内存都不太一样，那 可能会导致内存使用率的降低。所以一种替代的解决方案是，根据每个ms的内存大小，找出他们的最大公约数，然后在每个ms上开n个容量=最大公约数的 instance，这样就等于拥有了多个容量大小一样的子ms，从而提供整体的内存使用率。

缓存策略

当ms的hash表满了之后，新的插入数据会替代老的数据，更新的策略是LRU（最近最少使用），以及每个kv对的有效时限。Kv对存储有效时限是在mc端由app设置并作为参数传给ms的。

同时ms采用是偷懒替代法，ms不会开额外的进程来实时监测过时的kv对并删除，而是当且仅当，新来一个插入的数据，而此时又没有多余的空间放了，才会进行清除动作。

缓存数据库查询 现在memcached最流行的一种使用方式是缓存数据库查询，下面举一个简单例子说明：

App需要得到userid=xxx的用户信息，对应的查询语句类似：

“SELECT * FROM users WHERE userid = xxx”

App先去问cache，有没有“user:userid”（key定义可预先定义约束好）的数据，如果有，返回数据；如果没有，App会从数据库中读取数据，并调用cache的add函数，把数据加入cache中。

当取的数据需要更新，app会调用cache的update函数，来保持数据库与cache的数据同步。

从上面的例子我们也可以发现，一旦数据库的数据发现变化，我们一定要及时更新cache中的数据，来保证app读到的是同步的正确数据。当然我们可 以通过定时器方式记录下cache中数据的失效时间，时间一过就会激发事件对cache进行更新，但这之间总会有时间上的延迟，导致app可能从 cache读到脏数据，这也被称为狗洞问题。（以后我会专门描述研究这个问题）

数据冗余与故障预防

从设计角度上，memcached是没有数据冗余环节的，它本身就是一个大规模的高性能cache层，加入数据冗余所能带来的只有设计的复杂性和提高系统的开支。

当一个ms上丢失了数据之后，app还是可以从数据库中取得数据。不过更谨慎的做法是在某些ms不能正常工作时，提供额外的ms来支持cache，这样就不会因为app从cache中取不到数据而一下子给数据库带来过大的负载。

同时为了减少某台ms故障所带来的影响，可以使用“热备份”方案，就是用一台新的ms来取代有问题的ms，当然新的ms还是要用原来ms的IP地址，大不了数据重新装载一遍。

另外一种方式，就是提高你ms的节点数，然后mc会实时侦查每个节点的状态，如果发现某个节点长时间没有响应，就会从mc的可用server列表里 删除，并对server节点进行重新hash定位。当然这样也会造成的问题是，原本key存储在B上，变成存储在C上了。所以此方案本身也有其弱点，最好 能和“热备份”方案结合使用，就可以使故障造成的影响最小化。

Memcached客户端（mc）

Memcached客户端有各种语言的版本供大家使用，包括java，c，php，.net等等，具体可参见memcached api page[2]。 大家可以根据自己项目的需要，选择合适的客户端来集成。

缓存式的Web应用程序架构 有了缓存的支持，我们可以在传统的app层和db层之间加入cache层，每个app服务器都可以绑定一个mc，每次数据的读取都可以从ms中取得，如果 没有，再从db层读取。而当数据要进行更新时，除了要发送update的sql给db层，同时也要将更新的数据发给mc，让mc去更新ms中的数据。

假设今后我们的数据库可以和ms进行通讯了，那可以将更新的任务统一交给db层，每次数据库更新数据的同时会自动去更新ms中的数据，这样就可以进一步减少app层的逻辑复杂度。如下图：

不过每次我们如果没有从cache读到数据，都不得不麻烦数据库。为了最小化数据库的负载压力，我们可以部署数据库复写，用slave数据库来完成读取操作，而master数据库永远只负责三件事：1.更新数据；2.同步slave数据库；3.更新cache。如下图：

以上这些缓存式web架构在实际应用中被证明是能有效并能极大地降低数据库的负载同时又能提高web的运行性能。当然这些架构还可以根据具体的应用环境进行变种，以达到不同硬件条件下性能的最优化。

4.  安装

然后，将memcached主程序文件安装到服务器上。

Windows下安装：

1.将上图中Memcached 1.2.5.zip解压缩到 D:\program files\memcached目录下（此目录自行定义）。

2.Ctrl+R，输入cmd，打开命令行窗口，转到D:\program files\memcached目录下。

3.memcached.exe -d install

4.memcached.exe -d start

如果你要卸载，执行下面的命令：

1.memcached.exe -d stop

2.memcached.exe -d uninstall

Linux（CentOS 5.x）下安装：

1. yum install gcc

2. cd /tmp

3. wget http://www.monkey.org/~provos/libevent-2.0.4-alpha.tar.gz   注：memcached 用到了 libevent 这个库用于 Socket 的处理，所以 还需要安装 libevent

4. tar zxvf libevent-2.0.4-alpha.tar.gz

5. cd libevent-2.0.4-alpha

6. ./configure -prefix=/usr/local/libevent

7. make

8. make install

9. cd ~

10. cd /tmp

11. http://memcached.googlecode.com/files/memcached-1.4.5.tar.gz

12. tar zxvf memcached-1.4.5.tar.gz

13. cd memcached-1.4.5

14. ./configure -prefix=/usr/local/memcached --with-libevent=/usr/local/libevent    注：安装memcached时需要指定libevent的安装位置

15. make

16. make install

17. export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/libevent/lib   注：将libevent的lib目录加入LD_LIBRARY_PATH里

18. vi /etc/sysconfig/iptables

19. 将下面这行加入进去

-A RH-Firewall-l-INPUT -p tcp -m tcp --dport 11211 -j ACCEPT  注：将memcached加入到防火墙允许访问规则中

20. service iptables restart  注：防火墙重启

21. /usr/local/memcached/bin/memcached -d   注：启动memcached

memcached启动参数描述：

-d ：启动一个守护进程，

-m：分配给Memcache使用的内存数量，单位是MB，默认是64MB，

-u ：运行Memcache的用户

-l  ：监听的服务器IP地址

-p ：设置Memcache监听的端口，默认是11211    注：-p（p为小写）

-c ：设置最大并发连接数，默认是1024

-P ：设置保存Memcache的pid文件   注：-P（P为大写）

如果要结束Memcache进程，执行：kill cat pid文件路径

5      如何使用

• 建立Manager类

Java代码

1. package com.alisoft.sme.memcached;  

2. 
   

3. import java.util.Date;  

4. 
   

5. import com.danga.MemCached.MemCachedClient;  

6. import com.danga.MemCached.SockIOPool;  

7. 
   

8. public class MemCachedManager {  

9. 
   

10.    // 创建全局的唯一实例  

11.    protected static MemCachedClient mcc = new MemCachedClient();  

12. 
    

13.    protected static MemCachedManager memCachedManager = new MemCachedManager();  

14. 
    

15.    // 设置与缓存服务器的连接池  

16.    static {  

17.        // 服务器列表和其权重  

18.        String[] servers = { "127.0.0.1:11211" };  

19.        Integer[] weights = { 3 };  

20. 
    

21.        // 获取socke连接池的实例对象  

22.        SockIOPool pool = SockIOPool.getInstance();  

23. 
    

24.        // 设置服务器信息  

25.        pool.setServers(servers);  

26.        pool.setWeights(weights);  

27. 
    

28.        // 设置初始连接数、最小和最大连接数以及最大处理时间  

29.        pool.setInitConn(5);  

30.        pool.setMinConn(5);  

31.        pool.setMaxConn(250);  

32.        pool.setMaxIdle(1000 * 60 * 60 * 6);  

33. 
    

34.        // 设置主线程的睡眠时间  

35.        pool.setMaintSleep(30);  

36. 
    

37.        // 设置TCP的参数，连接超时等  

38.        pool.setNagle(false);  

39.        pool.setSocketTO(3000);  

40.        pool.setSocketConnectTO(0);  

41. 
    

42.        // 初始化连接池  

43.        pool.initialize();  

44. 
    

45.        // 压缩设置，超过指定大小（单位为K）的数据都会被压缩  

46.        mcc.setCompressEnable(true);  

47.        mcc.setCompressThreshold(64 * 1024);  

48.    }  

49. 
    

50.    /**

51.     * 保护型构造方法，不允许实例化！

52.     *  

53.     */  

54.    protected MemCachedManager() {  

55. 
    

56.    }  

57. 
    

58.    /**

59.     * 获取唯一实例.

60.     *  

61.     * @return

62.     */  

63.    public static MemCachedManager getInstance() {  

64.        return memCachedManager;  

65.    }  

66. 
    

67.    /**

68.     * 添加一个指定的值到缓存中.

69.     *  

70.     * @param key

71.     * @param value

72.     * @return

73.     */  

74.    public boolean add(String key, Object value) {  

75.        return mcc.add(key, value);  

76.    }  

77. 
    

78.    public boolean add(String key, Object value, Date expiry) {  

79.        return mcc.add(key, value, expiry);  

80.    }  

81. 
    

82.    public boolean replace(String key, Object value) {  

83.        return mcc.replace(key, value);  

84.    }  

85. 
    

86.    public boolean replace(String key, Object value, Date expiry) {  

87.        return mcc.replace(key, value, expiry);  

88.    }  

89. 
    

90.    /**

91.     * 根据指定的关键字获取对象.

92.     *  

93.     * @param key

94.     * @return

95.     */  

96.    public Object get(String key) {  

97.        return mcc.get(key);  

98.    }  

99. 
    

100.    public static void main(String[] args) {  

101.        MemCachedManager cache = MemCachedManager.getInstance();  

102.        cache.add("hello", 234);  

103.        System.out.print("get value : " + cache.get("hello"));  

104.    }  

105. }  

建立数据对象

Java代码

1. package com.alisoft.sme.memcached;  

2. 
   

3. import java.io.Serializable;  

4. 
   

5. public class TBean implements Serializable {  

6. 
   

7.    private static final long serialVersionUID = 1945562032261336919L;  

8. 
   

9.    private String name;  

10. 
    

11.    public String getName() {  

12.        return name;  

13.    }  

14. 
    

15.    public void setName(String name) {  

16.        this.name = name;  

17.    }  

18. }  

Java代码

1. <pre name="code" class="java"> </pre>  

2. 
   

3. <h2 style="margin: 13pt 0cm 13pt 28.8pt;"><span style="" lang="EN-US"><span style=""><span style="font-family: 'Times New Roman';">   </span></span></span><span style=""><span style="font-size: large;">创建测试用例</span></span></h2>  

4. <h2 style="margin: 13pt 0cm 13pt 28.8pt;"> </h2>  

5. <pre name="code" class="java">package com.alisoft.sme.memcached.test;  

6. 
   

7. import junit.framework.TestCase;  

8. 
   

9. import org.junit.Test;  

10. 
    

11. import com.alisoft.sme.memcached.MemCachedManager;  

12. import com.alisoft.sme.memcached.TBean;  

13. 
    

14. public class TestMemcached extends TestCase {  

15. 
    

16.    private static MemCachedManager cache;  

17. 
    

18.    @Test  

19.    public void testCache() {  

20. 
    

21.        TBean tb = new TBean();  

22.        tb.setName("E网打进");  

23.        cache.add("bean", tb);  

24. 
    

25.        TBean tb1 = (TBean) cache.get("bean");  

26.        System.out.println("name=" + tb1.getName());  

27.        tb1.setName("E网打进_修改的");  

28. 
    

29.        tb1 = (TBean) cache.get("bean");  

30.        System.out.println("name=" + tb1.getName());  

31.    }  

32. 
    

33.    @Override  

34.    protected void setUp() throws Exception {  

35.        super.setUp();  

36.        cache = MemCachedManager.getInstance();  

37.    }  

38. 
    

39.    @Override  

40.    protected void tearDown() throws Exception {  

41.        super.tearDown();  

42.        cache = null;  

43.    }  

44. 
    

45. }  

46. </pre>  

47. <h2 style="margin: 13pt 0cm 13pt 28.8pt;"> <span style="">测试结果</span></h2>  

48. <h2 style="margin: 13pt 0cm 13pt 28.8pt;"><span style="">  

49. <pre name="code" class="java">[INFO] ++++ serializing for key: bean for class: com.alisoft.sme.memcached.TBean  

50. [INFO] ++++ memcache cmd (result code): add bean 8 0 93 (NOT_STORED)  

51. [INFO] ++++ data not stored in cache for key: bean  

52. [INFO] ++++ deserializing class com.alisoft.sme.memcached.TBean  

53. name=E网打进  

54. [INFO] ++++ deserializing class com.alisoft.sme.memcached.TBean  

55. name=E网打进  

56. </pre>  

57. </span></h2>