Memcached是一个免费开源、高性能、分布式的内存对象缓存系统。Memcached是在内存中,为特定数据(字符串或对象)构建key-value的小块数据存储。
2. 下载Memcached的服务器端软件
Windows平台版本下载:http://splinedancer.com/memcached-win32/memcached-1.2.4-Win32-Preview-20080309_bin.zip
Linux平台版本下载:http://memcached.googlecode.com/files/memcached-1.4.10.tar.gz
3. 在服务器上部署Memcached Server
以下以Windows平台为例:
参考:
http://www.codeforest.net/how-to-install-memcached-on-windows-machine
下载下来的Windows版本解压到C:/memcached/
在控制台输入命令安装:
c:/memcached/memcached.exe -d install |
启动:
c:/memcached/memcached.exe -d start |
或:
net start "memcached Server" |
默认的缓存大小为64M,如果不够用,请打开注册表,找到:
HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/Services/memcached Server . |
将其内容修改为:
“C:/memcached/memcached.exe” -d runservice -m 512 |
4. 下载Memcached的客户端API包
下载地址:http://spymemcached.googlecode.com/files/memcached-2.5.jar
5. 编写一个Java数据类
- package com.sinosuperman.memcached;
-
- import java.io.Serializable;
-
-
- public class User implements Serializable{
-
- private static final long serialVersionUID = -372274003834027815L;
-
- String userId;
-
- public User(String userId) {
- super();
- this.userId = userId;
- }
-
- public String getUserId() {
- return userId;
- }
-
- public void setUserId(String userId) {
- this.userId = userId;
- }
-
- @Override
- public String toString() {
-
- StringBuffer sb=new StringBuffer();
- sb.append("userId="+this.userId);
- return sb.toString();
- }
- }
|
6. 编写一个Memcached的客户端
- package com.sinosuperman.memcached;
-
- import java.io.IOException;
- import java.net.InetSocketAddress;
-
- import net.spy.memcached.MemcachedClient;
-
- public class TestMemcached {
- public static void main(String[] args) throws IOException {
- MemcachedClient cache = new MemcachedClient(new InetSocketAddress("127.0.0.1", 11211));
- for (int i = 1; i < 10; i++) {
- cache.set("T0001" + i, 3600, new User(i + ""));
- }
- User myObject = (User) cache.get("T00011");
- System.out.println("Get object from mem :" + myObject);
- }
- }
|
7. 运行测试
运行结果应该如下:
- 2011-12-15 17:25:30.276 INFO net.spy.memcached.MemcachedConnection: Added {QA sa=/127.0.0.1:11211, #Rops=0, #Wops=0, #iq=0, topRop=null, topWop=null, toWrite=0, interested=0} to connect queue
- 2011-12-15 17:25:30.292 INFO net.spy.memcached.MemcachedConnection: Connection state changed for sun.nio.ch.SelectionKeyImpl@c62080
- Get object from mem :userId=1
|
1. 构造函数
public MemcachedClient(InetSocketAddress[] ia) throws IOException; |
public MemcachedClient(List<InetSocketAddress> addrs) throws IOException; |
public MemcachedClient(ConnectionFactory cf, List<InetSocketAddress> addrs) throws IOException; |
其中最简单的构造函数就是第一个,可以直接传递一个InetSocketAddress,也可以是InetSocketAddress的数组。其实InetSocketAddress也是被转换成数组的。
比如:
MemcachedClient cache = new MemcachedClient(new InetSocketAddress("127.0.0.1", 11211)); |
2. 常用方法
一般缓存数据的常用操作有:set(add+replace)、get、replace、add
public Future<Boolean> set(String key, int exp, Object o) |
第一个参数:键(key)
第二个参数:过期时间(单位是秒)
第三个参数:要设置缓存中的对象(value),如果没有则插入,如果有则修改。
public Object get(String key) |
第一个参数:键(key)
public Future<Boolean> replace(String key, int exp, Object o) |
第一个参数:键(key)
第二个参数:过期时间(单位是秒)
第三个参数:该键的新值(new value),如果有则修改。
public Future<Boolean> add(String key, int exp, Object o) |
第一个参数:键(key)
第二个参数:过期时间(单位是秒)
第三个参数:该键的值(value),如果没有则插入。
一、基本参数
在我们第一次安装Memcached时,一般都是用过这个命令:
memcached -m 512 -u root -d -l 127.0.0.1 -p 11211 |
我们先来解释这几个参数的含义吧。
-m 指定缓存所使用的最大内存容量,单位是Megabytes,默认是64MB
-u 只有以root身份运行时才指定该参数
-d 以daemon的形式运行
-l 指定监听的地址
-p 指定监听的TCP端口号,默认是11211
二、其他常用的参数
-t 指定线程数,默认是4个
-h 打印帮助信息
-c 最大同时连接数,默认是1024.
-U 指定监听的UDP端口号,默认是11211
-M 内存耗尽时显示错误,而不是删除项
一开始说的“-d”参数需要进行进一步的解释
-d install 安装memcached
-d uninstall 卸载memcached
-d start 启动memcached服务
-d restart 重启memcached服务
-d stop 停止memcached服务
-d shutdown 停止memcached服务
三、更多参数
使用"-h"去了解吧~
四、使用服务软件的经验
写到这里,最后说一句。在使用任何软件的时候,首先要去关注这样几点:
1. 打印帮助信息:
这个一般都是“-h”,当然也有需要“-help”才可以的。
2. 启动、停止、重启/重载配置的命令:
要注意,是同一个命令的不同参数来标识的,还是用不同的命令或脚本。
3. 配置
首先,启动是否需要配置文件。
其次,如果是比较大型的软件,一般都需要配置文件,那么默认的配置文件在哪里要清楚。
再次,指定加载配置文件的命令格式如何。
4. 指定使用内存容量、线程数、硬盘容量等
是否有这方面的配置参数需要指定,以及如何设置。
5. 日志文件
首先,是否有日志文件需要存储。
其次,如果有日志文件,默认的存储目录是什么。
最后,手动指定日志文件的命令格式如何。
6. 最大连接数
首先,是否提供监听的连接服务。
其次,如果提供,默认的最大连接数是多少。
最后,手动指定最大连接数的命令格式如何。
1. 什么是CAS协议
很多中文的资料都不会告诉大家CAS的全称是什么,不过一定不要把CAS当作中国科学院(China Academy of Sciences)的缩写。Google.com一下,CAS是什么?CAS是Check And Set的缩写。
2. CAS协议原文 http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt
3. CAS的基本原理
基本原理非常简单,一言以蔽之,就是“版本号”。每个存储的数据对象,多有一个版本号。我们可以从下面的例子来理解:
如果不采用CAS,则有如下的情景:
第一步,A取出数据对象X;
第二步,B取出数据对象X;
第三步,B修改数据对象X,并将其放入缓存;
第四步,A修改数据对象X,并将其放入缓存。
我们可以发现,第四步中会产生数据写入冲突。
如果采用CAS协议,则是如下的情景。
第一步,A取出数据对象X,并获取到CAS-ID1;
第二步,B取出数据对象X,并获取到CAS-ID2;
第三步,B修改数据对象X,在写入缓存前,检查CAS-ID与缓存空间中该数据的CAS-ID是否一致。结果是“一致”,就将修改后的带有CAS-ID2的X写入到缓存。
第四步,A修改数据对象Y,在写入缓存前,检查CAS-ID与缓存空间中该数据的CAS-ID是否一致。结果是“不一致”,则拒绝写入,返回存储失败。
这样CAS协议就用了“版本号”的思想,解决了冲突问题。
1. 非CAS
首先看一个不是CAS的Memcached程序实例。实例的问题原型,见上一篇博文。
程序实例:
- package com.sinosuperman.memcached;
-
- import java.io.IOException;
- import java.net.InetSocketAddress;
-
- import net.spy.memcached.MemcachedClient;
-
- public class Test {
- public static void main(String[] args) throws IOException {
- MemcachedClient cache = new MemcachedClient(new InetSocketAddress("127.0.0.1", 11211));
-
- cache.set("x", 1800, "Love");
-
- String obj1 = (String) cache.get("x");
- String obj2 = (String) cache.get("x");
- obj2 = "Michael";
-
- cache.set("x", 1800, obj2);
- System.out.println("Non-CAS 2:t" + obj2);
- System.out.println("Non-CAS 1:t" + obj1);
- }
- }
|
运行结果:
- 2011-12-18 23:12:39.836 INFO net.spy.memcached.MemcachedConnection: Added {QA sa=/127.0.0.1:11211, #Rops=0, #Wops=0, #iq=0, topRop=null, topWop=null, toWrite=0, interested=0} to connect queue
- 2011-12-18 23:12:39.843 INFO net.spy.memcached.MemcachedConnection: Connection state changed for sun.nio.ch.SelectionKeyImpl@b09e89
- Non-CAS 2: Michael
- Non-CAS 1: Love
|
可见在多个Client操作时,一定会引起写不一致性的问题。
2. CAS
程序实例:
- package com.sinosuperman.memcached;
-
- import java.io.IOException;
- import java.net.InetSocketAddress;
-
- import net.spy.memcached.CASValue;
- import net.spy.memcached.MemcachedClient;
-
- public class Test {
- @SuppressWarnings("unchecked")
- public static void main(String[] args) throws IOException {
- MemcachedClient cache = new MemcachedClient(new InetSocketAddress("127.0.0.1", 11211));
-
- cache.set("y", 1800, "Love");
-
- CASValue casValue1 = cache.gets("y");
- CASValue casValue2 = cache.gets("y");
- cache.cas("y", casValue2.getCas(), casValue2.getValue());
-
- System.out.println("CAS 2:t" + casValue2.getCas());
- System.out.println("Value 2:t" + casValue2.getValue());
-
- System.out.println("CAS 1:t" + casValue1.getCas());
- System.out.println("Value 1:t" + casValue1.getValue());
- }
- }
|
运行结果:
- 2011-12-18 23:07:14.528 INFO net.spy.memcached.MemcachedConnection: Added {QA sa=/127.0.0.1:11211, #Rops=0, #Wops=0, #iq=0, topRop=null, topWop=null, toWrite=0, interested=0} to connect queue
- 2011-12-18 23:07:14.541 INFO net.spy.memcached.MemcachedConnection: Connection state changed for sun.nio.ch.SelectionKeyImpl@1621e42
- CAS 2: 11
- Value 2: Love
- CAS 1: 11
- Value 1: Love
|
1. 源程序
- package com.sinosuperman.memcached;
-
- import java.io.IOException;
- import java.net.InetSocketAddress;
-
- import net.spy.memcached.CASResponse;
- import net.spy.memcached.CASValue;
- import net.spy.memcached.MemcachedClient;
-
-
- public class Test {
-
- private static MemcachedClient client = null;
-
- static {
- try {
- client = new MemcachedClient(new InetSocketAddress("localhost", 11211));
- } catch (IOException o) {
- }
- }
-
- public static void main(String[] args) throws Exception {
-
- client.set("numberss", 1800, 1);
-
- Test testObj = new Test();
- for (int i = 0; i < 10; i++) {
- testObj.new ThreadTest("Thread-" + (i + 1)).start();
- }
- }
-
- private class ThreadTest extends Thread {
-
- private MemcachedClient client = null;
- ThreadTest(String name) throws IOException {
- super(name);
- client = new MemcachedClient(new InetSocketAddress("localhost", 11211));
- }
-
- public void run() {
- int i = 0;
- int success = 0;
- while (i < 10) {
- i++;
- CASValue<Object> uniqueValue =client.gets("numberss");
- CASResponse response = client.cas("numberss",
- uniqueValue.getCas(), (Integer)uniqueValue.getValue() + 1);
-
- if (response.toString().equals("OK")) {
- success++;
- }
-
- if (i == 10)
- System.out.println(Thread.currentThread().getName() + " " + i
- + " time " + " update oldValue : " + uniqueValue.getValue()
- + " , result : " + response);
- }
-
- if (success < 10) {
- Count.incr(10 - success);
- System.out.println("Test counter: " + Count.get());
- }
- }
- }
-
- public static class Count {
- private static int counter = 0;
- public static void incr(int x) {
- counter += x;
- }
- public static int get() {
- return counter;
- }
- }
- }
|
2. 输出结果:
- Thread-1 10 time update oldValue : 14 , result : EXISTS
- Test counter: 6
- Thread-2 10 time update oldValue : 14 , result : EXISTS
- Test counter: 15
- Thread-3 10 time update oldValue : 17 , result : EXISTS
- Test counter: 22
- Thread-5 10 time update oldValue : 17 , result : EXISTS
- Test counter: 27
- Thread-4 10 time update oldValue : 20 , result : OK
- Test counter: 33
- Thread-8 10 time update oldValue : 27 , result : OK
- Test counter: 36
- Thread-6 10 time update oldValue : 28 , result : EXISTS
- Test counter: 43
- Thread-10 10 time update oldValue : 31 , result : EXISTS
- Test counter: 52
- Thread-9 10 time update oldValue : 31 , result : OK
- Test counter: 60
- Thread-7 10 time update oldValue : 35 , result : OK
- Test counter: 65
|
3. 分析
我们可以看到,未成功的次数最终为65,数据值最终为35,两者的和刚好是100,正好符合我们的实验结果预期。
1. Memcached是什么?
Memcached是分布式的内存对象缓存系统。
2. Memcached的基本数据结构是什么?
Memcached是基于Key/Value对的HashMap。每一对,都可以设定过期时间。
3. Memcached用什么实现?
服务端程序由C语言编写,客户端可以用任何语言编写。客户端通过Memcached协议与服务端通信。
4. Memcached特点
(1)无备份/冗余:
各Memcached节点的数据之间没有互相备份,一旦某个节点挂掉,缓存中的数据就会丢失。
5. 开发团队
Memcached由Danga Interactive开发。
6. 相关下载
(1)Memcached服务端程序
http://memcached.org/
(2)Memcached的客户端程序
http://code.google.com/p/memcached/wiki/Clients
(3)Memcached可视化管理系统(PHP和jQuery编写)
http://www.junopen.com/memadmin
7. 如何理解Memcached的分布式特点?
Memcached Server并不具有分布式特征,每个Server都是独立运行的,各Server之间不存在通信获知其他节点状态和数据备份的功能。那么Memcached为什么还是分布式的缓存系统呢?其实说到Memcached的分布式,是将Memcached Client结合在一起考虑的。具体的分布式策略,由Client实现。也就是说Memcached的分布式,不是系统层的,而是应用层的。
在使用Memcached时,一般实时读写的场景并不多见。但多是Memcached写入后,在一定时间后才会有读操作。但是如果应用场景,是写入后瞬间即会有读操作呢?似乎没有什么特别之处,我们依然可以这样写:
注:此处使用的是spymemcached客户端。
- MemcachedClient cache = new MemcachedClient(cacheServerAddr);
- cache.set("key", 3600, bigData);
- return cache.get("key");
|
如此写入缓存后,如果立刻就有其他客户端进行读操作,则会读取失败,因为set是同步操作(sync),很可能仍还没有写入完。
一种可行的方法,是采用同步写操作。常用的set方法没有这种方式,需要采用遵守Memcached的CAS(Check And Set)协议的写操作。而这种写操作,一般是基于读取后得到CAS ID(类似于SVN中的版本ID),根据这个CAS ID来保证写入时,没有和其他写入操作产生“写重复”冲突。因此,在我们现在所讨论的场景中,可以如下使用CAS协议:
(1)初始写入:写一个简单的初始值;
(2)获取版本:使用异步方式获取CAS ID;
(3)同步写入:以同步方式写入数据,保证在读取前,已经写入结束。
- MemcachedClient cache = new MemcachedClient(cacheServerAddr);
- cache.set(“key”, 3600, "");
- long casId = cache.asyncGets("key").get().getCas();
- cache.cas("key", cased, bigData);
- return cache.get("key");
|
以这种“Set-Asyncgets-Cas”方式的缓存异步实时读写问题的解决方案,我们称之为“SAC”(你一定想到了什么??)。