Memcached服务器安装、配置、使用详解

我使用的是CentOS 6.4系统，安装的Memcached版本为1.4.20。这里，记录一下安装配置的过程，以及如何使用一些常用的客户端来访问Memcached存储的数据。

安装配置

首先，编译、安装、配置libevent库，执行如下命令：

1	wget https://github.com/downloads/libevent/libevent/libevent-1.4.14b-stable.tar.gz

2	tar xvzf libevent-1.4.14b-stable.tar.gz

3	ln -s /usr/local/libevent-1.4.14b-stable /usr/local/libevent

4	cd /usr/local/libevent

5	./configure

6

make

7	make install

然后，编译、安装、配置Memcached，执行如下命令行：

1	wget http://www.memcached.org/files/memcached-1.4.20.tar.gz

2	tar xvzf memcached-1.4.20.tar.gz

3	ln -s /usr/local/memcached-1.4.20 /usr/local/memcached

4	./configure --with-libevent=/usr/local/libevent/

5

make

6	make install

如果没有出错，安装成功。

管理memcached服务

• 启动Memcached

一般情况下，简单地可以使用类似如下形式，启动Memcached服务：

1	/usr/local/bin/memcached -d -m 64 -I 20m -u root -l 192.168.4.86 -p 11211 -c 1024 -P /usr/local/memcached/memcached.pid

上述命令行中，基于上面各个选项，以及其他一些选项的含义，说明如下表所示：

选项	含义说明
-d	指定memcached进程作为一个守护进程启动
-m <num>	指定分配给memcached使用的内存，单位是MB
-u <username>	运行memcached的用户
-l <ip_addr>	监听的服务器IP地址，如果有多个地址的话，使用逗号分隔，格式可以为“IP地址:端口号”，例如：-l 指定192.168.0.184:19830,192.168.0.195:13542；端口号也可以通过-p选项指定
-p <num>	Memcached监听的端口，要保证该端口号未被占用
-c <num>	设置最大运行的并发连接数，默认是1024
-R <num>	为避免客户端饿死（starvation），对连续达到的客户端请求数设置一个限额，如果超过该设置，会选择另一个连接来处理请求，默认为20
-k	设置锁定所有分页的内存，对于大缓存应用场景，谨慎使用该选项
-P	保存memcached进程的pid文件
-s <file>	指定Memcached用于监听的UNIX socket文件
-a <perms>	设置-s选项指定的UNIX socket文件的权限
-U <num>	指定监听UDP的端口，默认11211，0表示关闭
-M	当内存使用超出配置值时，禁止自动清除缓存中的数据项，此时Memcached不可以，直到内存被释放
-r	设置产生core文件大小
-f <factor>	用于计算缓存数据项的内存块大小的乘数因子，默认是1.25
-n	为缓存数据项的key、value、flag设置最小分配字节数，默认是48
-C	禁用CAS
-h	显示Memcached版本和摘要信息
-v	输出警告和错误信息
-vv	打印信息比-v更详细：不仅输出警告和错误信息，也输出客户端请求和响应信息
-i	打印libevent和Memcached的licenses信息
-t <threads>	指定用来处理请求的线程数，默认为4
-D <char>	用于统计报告中Key前缀和ID之间的分隔符，默认是冒号“:”
-L	尝试使用大内存分页（pages）
-B <proto>	指定使用的协议，默认行为是自动协商（autonegotiate），可能使用的选项有auto、ascii、binary。
-I <size>	覆盖默认的STAB页大小，默认是1M
-F	禁用flush_all命令
-o <options>	指定逗号分隔的选项，一般用于用于扩展或实验性质的选项

• 停止Memcached

可以通过Linux的如下命令查询到Memcached的进程号：

1	ps -ef | grep memcached

然后杀掉Memcached服务进程：

1	kill -9 <PID>

-9表示强制杀掉进程。

Memcached启动以后，可以通过客户端来操作缓存中的数据，我们说明一些常用的客户端，及其使用方法。

Telnet客户端

Telnet客户端可以通过命令行的方式来监控查看Memcached服务器存储数据的情况。例如，Memcached的服务地址为192.168.4.86:11211，可以telnet到该服务端口：

1	telnet 192.168.4.86 11211

如果连接成功，可以使用如下一些命令：

• stats命令

该命令用于显示服务器信息、统计数据等，结果示例数据（来自www.2cto.com网站），例如：

01	STAT pid 22362    //memcache服务器的进程ID  www.2cto.com

02	STAT uptime 1469315    //服务器已经运行的秒数

03	STAT time 1339671194    //服务器当前的unix时间戳

04	STAT version 1.4.9    //memcache版本

05	STAT libevent 1.4.9-stable    //libevent版本

06	STAT pointer_size 64    //当前操作系统的指针大小（32位系统一般是32bit,64就是64位操作系统）

07	STAT rusage_user 3695.485200    //进程的累计用户时间

08	STAT rusage_system 14751.273465    //进程的累计系统时间

09	STAT curr_connections 69    //服务器当前存储的items数量

10	STAT total_connections 855430    //从服务器启动以后存储的items总数量

11	STAT connection_structures 74    //服务器分配的连接构造数

12	STAT reserved_fds 20    //

13	STAT cmd_get 328806688    //get命令（获取）总请求次数

14	STAT cmd_set 75441133    //set命令（保存）总请求次数  www.2cto.com

15	STAT cmd_flush 34    //flush命令请求次数

16	STAT cmd_touch 0    //touch命令请求次数

17	STAT get_hits 253547177    //总命中次数

18	STAT get_misses 75259511    //总未命中次数

19	STAT delete_misses 4    //delete命令未命中次数

20	STAT delete_hits 565730    //delete命令命中次数

21	STAT incr_misses 0    //incr命令未命中次数

22	STAT incr_hits 0    //incr命令命中次数

23	STAT decr_misses 0    //decr命令未命中次数

24	STAT decr_hits 0    //decr命令命中次数

25	STAT cas_misses 0    //cas命令未命中次数

26	STAT cas_hits 0        //cas命令命中次数

27	STAT cas_badval 0    //使用擦拭次数

28	STAT touch_hits 0    //touch命令未命中次数

29	STAT touch_misses 0    //touch命令命中次数

30	STAT auth_cmds 0    //认证命令处理的次数

31	STAT auth_errors 0    //认证失败数目

32	STAT bytes_read 545701515844        //总读取字节数（请求字节数）

33	STAT bytes_written 1649639749866    //总发送字节数（结果字节数）

34	STAT limit_maxbytes 2147483648        //分配给memcache的内存大小（字节）

35	STAT accepting_conns 1            //服务器是否达到过最大连接（0/1）

36	STAT listen_disabled_num 0    //失效的监听数

37	STAT threads 4        //当前线程数

38	STAT conn_yields 14    //连接操作主动放弃数目

39	STAT hash_power_level 16    //

40	STAT hash_bytes 524288

41	STAT hash_is_expanding 0

42	STAT expired_unfetched 30705763

43	STAT evicted_unfetched 0

44	STAT bytes 61380700    //当前存储占用的字节数

45	STAT curr_items 28786    //当前存储的数据总数

46	STAT total_items 75441133    //启动以来存储的数据总数

47	STAT evictions 0    //为获取空闲内存而删除的items数（分配给memcache的空间用满后需要删除旧的items来得到空间分配给新的items)

48	STAT reclaimed 39957976    //已过期的数据条目来存储新数据的数目

49

END

上面给出了各个统计项的含义说明，不再累述。
stats命令有几个二级子项，说明如下表所示：

命令	含义说明
stats slabs	显示各个slab的信息，包括chunk的大小、数目、使用情况等
stats items	显示各个slab中item的数目和最老item的年龄（最后一次访问距离现在的秒数）
stats detail [on|off|dump]	设置或者显示详细操作记录； 参数为on，打开详细操作记录； 参数为off，关闭详细操作记录； 参数为dump，显示详细操作记录（每一个键值get、set、hit、del的次数）
stats malloc	打印内存分配信息
stats sizes	打印缓存使用信息
stats reset	重置统计信息

下面的命令，我们通过表格的形式说明，如下表所示：

命令	用法格式	含义说明	示例
get	get <key>*\r\n	用于获取缓存的数据，键为key。	get name VALUE name 0 7 shirdrn END
gets	gets <key>*\r\n	用于获取缓存的数据，键为一组key。	gets name hobby VALUE name 1 7 1234567 VALUE hobby 0 25 tenis basketball football END
set	set <key> <flags> <exptime> <bytes> [noreply]\r\n<value>\r\n	向缓存中存储数据，不管key对应的值存在与否，都设置key对应的值。	set name 0 1800 7 shirdrn STORED get name VALUE name 0 7 shirdrn END
touch	touch <key> <exptime> [noreply]\r\n	更新缓存中key对应的值的过期时间。	touch name 1800
delete	delete <key> [<time>] [noreply]\r\n	给定键key，删除缓存中key对应的数据。	delete name 60
add	add <key> <flags> <exptime> <bytes> [noreply]\r\n<value>\r\n	向缓存中存储数据，只有key对应的值不存在时，才会设置key对应的值。	add hobby 0 1800 10 basketball STORED get hobby VALUE hobby 0 10 basketball END
replace	replace <key> <flags> <exptime> <bytes> [noreply]\r\n<value>\r\n	覆盖一个已经存在Key及其对应的Value，替换一定要保证替换后的值的长度原始长度相同，否则replace失败。	get name VALUE name 0 7 shirdrn END replace name 0 1800 7 youak47 STORED get name VALUE name 0 7 youak47 END
append	append <key> <flags> <exptime> <bytes> [noreply]\r\n<value>\r\n	在一个已经存在的数据值（value）上追加，是在数据值的后面追加。	get hobby VALUE hobby 0 10 basketball END append hobby 0 1800 9 football STORED get hobby VALUE hobby 0 19 basketball football END
prepend	prepend <key> <flags> <exptime> <bytes> [noreply]\r\n<value>\r\n	在一个已经存在的数据值（value）上追加，是在数据值的前面追加。	get hobby VALUE hobby 0 19 basketball football END prepend hobby 0 1800 6 tenis STORED get hobby VALUE hobby 0 25 tenis basketball football END
incr	incr <key> <value> [noreply]\r\n	计数命令，可以在原来已经存在的数字上进行累加求和，计算并存储新的数值。	set active_users 0 1000000 7 1000000 STORED get active_users VALUE active_users 0 7 1000000 END incr active_users 99 1000099
decr	decr <key> <value> [noreply]\r\n	计数命令，可以在原来已经存在的数字上进行减法计算，计算并存储新的数值。	get active_users VALUE active_users 0 7 1000099 END decr active_users 3456 996643
flush_all	flush_all [<time>] [noreply]\r\n	使缓存中的数据项失效，可选参数是在多少秒后失效。	flush_all 1800
version	version\r\n	返回Memcached服务器的版本信息。	version
quit	quit\r\n	退出telnet终端。	quit

Java客户端

可以使用Java语言编写代码来访问Memcached缓存。目前，可以使用的Java客户端很多，这里简单介绍几个。

• spymemcached客户端

示例代码，如下所示：

01	package org.shirdrn.spymemcached;

02

03	import net.spy.memcached.AddrUtil;

04	import net.spy.memcached.BinaryConnectionFactory;

05	import net.spy.memcached.MemcachedClient;

06	import net.spy.memcached.internal.OperationFuture;

07

08	public class TestSpymemcached {

09

10	public static void main(String[] args) throws Exception {

11	String address = "192.168.4.86:11211";

12	MemcachedClient client = new MemcachedClient(new BinaryConnectionFactory(),

13	AddrUtil.getAddresses(address));

14

15	String key = "magic_words";

16	int exp = 3600;

17	String o = "hello";

18

// set

19	OperationFuture<Boolean> setFuture = client.set(key, exp, o);

20	if(setFuture.get()) {

21

// get

22	System.out.println(client.get(key));

23

24

// append

25	client.append(key, " the world!");

26	System.out.println(client.get(key));

27

28	// prepend

29	client.prepend(key, "Stone, ");

30	System.out.println(client.get(key));

31

32	// replace

33	o = "This is a test for spymemcached.";

34	OperationFuture<Boolean> replaceFuture = client.replace(key, exp, o);

35	if(replaceFuture.get()) {

36	System.out.println(client.get(key));

37

38

// delete

39	client.delete(key);

40	System.out.println(client.get(key));

41

}

42

}

43

44	client.shutdown();

45

}

46

47

}

更多用法，可以参考后面的链接。

• XMemcached客户端

示例代码，如下所示：

001	package org.shirdrn.xmemcached;

002

003	import java.io.File;

004	import java.io.IOException;

005	import java.io.Serializable;

006	import java.net.InetSocketAddress;

007	import java.util.Arrays;

008	import java.util.List;

009	import java.util.Map;

010	import java.util.concurrent.ExecutorService;

011	import java.util.concurrent.Executors;

012	import java.util.concurrent.TimeoutException;

013	import java.util.concurrent.atomic.AtomicLong;

014

015	import net.rubyeye.xmemcached.CASOperation;

016	import net.rubyeye.xmemcached.GetsResponse;

017	import net.rubyeye.xmemcached.MemcachedClient;

018	import net.rubyeye.xmemcached.XMemcachedClientBuilder;

019	import net.rubyeye.xmemcached.command.BinaryCommandFactory;

020	import net.rubyeye.xmemcached.exception.MemcachedException;

021	import net.rubyeye.xmemcached.utils.AddrUtil;

022

023	public class UsingXMemcachedClient {

024

025	public static void main(String[] args) throws IOException {

026	String servers = "192.168.4.86:11211";

027	// build and create a client

028	XMemcachedClientBuilder builder = new XMemcachedClientBuilder(

029	AddrUtil.getAddresses(servers));

030	builder.setCommandFactory(new BinaryCommandFactory());

031	final MemcachedClient client = builder.build();

032

033	// examples using client to operate

034	final String key = "ghost";

035

try {

036

// add

037	client.add(key, 0, "Ghost wind blows!");

038	System.out.println("add & get: " + client.get(key));

039

040

// append

041	client.append(key, " It's a lie.");

042	System.out.println("append & get: " + client.get(key));

043

044	// prepend

045	client.prepend(key, "Who's said?! ");

046	System.out.println("prepend & get: " + client.get(key));

047

048	// replace

049	client.replace(key, 0, "Everything is nothing!");

050	System.out.println("replace & get: " + client.get(key));

051

052

// delete

053	client.delete(key);

054	System.out.println("delete & get: " + client.get(key));

055

056

// gets

057	List<String> keys = Arrays.asList(new String[] {

058	"key1", "key2", "key3"

059

});

060	for(String k : keys) {

061	client.set(k, 3600, "v:" + System.nanoTime());

062

}

063	Map<String, GetsResponse<Object>> values = client.gets(keys);

064	for(Map.Entry<String, GetsResponse<Object>> entry : values.entrySet()) {

065	System.out.println("key=" + entry.getKey() + ", value=" + entry.getValue().getValue());

066

}

067

068

// cas

069	final AtomicLong seq = new AtomicLong(System.nanoTime());

070	ExecutorService pool = Executors.newCachedThreadPool();

071	for(int i=0; i<10; i++) {

072	pool.execute(new Runnable() {

073

@Override

074	public void run() {

075	while(true) {

076	CacheResult o = new CacheResult();

077	o.file = new File("/opt/status/servers.lst");

078	o.lastmodified = seq.incrementAndGet();

079	System.out.println("#" + Thread.currentThread().getId() + "=>o: " + o);

080

try {

081	client.set(key, 0, o);

082	Thread.sleep(100);

083	} catch (TimeoutException e) {

084	// TODO Auto-generated catch block

085	e.printStackTrace();

086	} catch (InterruptedException e) {

087	// TODO Auto-generated catch block

088	e.printStackTrace();

089	} catch (MemcachedException e) {

090	// TODO Auto-generated catch block

091	e.printStackTrace();

092

}

093

}

094

}

095

});

096

}

097	Thread.sleep(3000);

098	for(int i=0; i<10; i++) {

099	client.cas(key, new CASOperation<CacheResult>() {

100

@Override

101	public int getMaxTries() {

102

return 3;

103

}

104

@Override

105	public CacheResult getNewValue(long arg0, CacheResult result) {

106	CacheResult old = result;

107	CacheResult nu = new CacheResult();

108	nu.file = old.file;

109	nu.lastmodified = seq.incrementAndGet();

110	System.out.println("cas: old=" + old + ", new=" + nu);

111	return result;

112

}

113

});

114

}

115	pool.shutdown();

116

117	// flush_all

118	client.flushAll();

119

120

// stats

121	List<InetSocketAddress> addresses = AddrUtil.getAddresses(servers);

122	for(InetSocketAddress addr : addresses) {

123	Map<String, String> stats = client.stats(addr);

124	System.out.println(stats);

125

}

126

127	} catch (TimeoutException e) {

128	e.printStackTrace();

129	} catch (InterruptedException e) {

130	e.printStackTrace();

131	} catch (MemcachedException e) {

132	e.printStackTrace();

133

}

134

135	synchronized(client) {

136

try {

137	client.wait();

138	} catch (InterruptedException e) {

139	e.printStackTrace();

140

}

141

}

142

143

}

144

145	static class CacheResult implements Serializable {

146	private static final long serialVersionUID = 3349686173080590047L;

147	private File file;

148	private long lastmodified;

149

@Override

150	public String toString() {

151	return "file=[" + file + ", lastmodified=" + lastmodified + "]";

152

}

153

}

154

155

}

Node.js客户端

Memcached客户端代码的逻辑都非常类似，这里对Node.js简单举例说明，代码如下所示：

查看源代码

打印 帮助

01	#!/usr/bin/env node

02

03	var MemcachedClient = require('memcached');

04

05	// configure memcached client

06	var servers = ['192.168.4.86:11211'];

07	var client = new MemcachedClient(servers);

08

09	// access memcached servers

10	var key = 'ghost';

11

12

// set

13	var value = 'Ghost wind blows!';

14	client.set(key, 0, value, function(err) {

15	var data = 'key=' + key + ', value=' + value;

16

if(err) {

17	console.error('Fail to set: ' + data);

18

} else {

19	console.log('Added: ' + data);

20

}

21

});

22

23

// get

24	var valueGot = client.get(key, function(err, data) {

25	var dataGot = 'key=' + key + ', valueGot=' + data;

26

if(err) {

27	console.error('Fail to get: ' + dataGot);

28

} else {

29	console.log('Got: ' + dataGot);

30

}

31

});

参考链接