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

我使用的是CentOS 6.4系统，安装的Memcached版本为1.4.20。这里，记录一下安装配置的过程，以及如何使用一些常用的客户端来访问Memcached存储的数据。 安装配置 首先，编译、安装、配置libevent库，执行如下命令： wget https://github.com/downloads/libeve

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

安装配置

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

wget https://github.com/downloads/libevent/libevent/libevent-1.4.14b-stable.tar.gz
tar xvzf libevent-1.4.14b-stable.tar.gz
ln -s /usr/local/libevent-1.4.14b-stable /usr/local/libevent
cd /usr/local/libevent
./configure
make
make install

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

wget http://www.memcached.org/files/memcached-1.4.20.tar.gz
tar xvzf memcached-1.4.20.tar.gz
ln -s /usr/local/memcached-1.4.20 /usr/local/memcached
./configure --with-libevent=/usr/local/libevent/
make
make install

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

管理memcached服务

• 启动Memcached

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

/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

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

• 停止Memcached

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

ps -ef | grep memcached

然后杀掉Memcached服务进程：

kill -9 

-9表示强制杀掉进程。

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

Telnet客户端

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

telnet 192.168.4.86 11211

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

• stats命令

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

STAT pid 22362    //memcache服务器的进程ID  www.2cto.com 
STAT uptime 1469315    //服务器已经运行的秒数
STAT time 1339671194    //服务器当前的unix时间戳
STAT version 1.4.9    //memcache版本
STAT libevent 1.4.9-stable    //libevent版本
STAT pointer_size 64    //当前操作系统的指针大小（32位系统一般是32bit,64就是64位操作系统）
STAT rusage_user 3695.485200    //进程的累计用户时间
STAT rusage_system 14751.273465    //进程的累计系统时间
STAT curr_connections 69    //服务器当前存储的items数量
STAT total_connections 855430    //从服务器启动以后存储的items总数量
STAT connection_structures 74    //服务器分配的连接构造数
STAT reserved_fds 20    //
STAT cmd_get 328806688    //get命令（获取）总请求次数
STAT cmd_set 75441133    //set命令（保存）总请求次数  www.2cto.com 
STAT cmd_flush 34    //flush命令请求次数
STAT cmd_touch 0    //touch命令请求次数
STAT get_hits 253547177    //总命中次数
STAT get_misses 75259511    //总未命中次数
STAT delete_misses 4    //delete命令未命中次数
STAT delete_hits 565730    //delete命令命中次数
STAT incr_misses 0    //incr命令未命中次数
STAT incr_hits 0    //incr命令命中次数
STAT decr_misses 0    //decr命令未命中次数
STAT decr_hits 0    //decr命令命中次数
STAT cas_misses 0    //cas命令未命中次数
STAT cas_hits 0        //cas命令命中次数
STAT cas_badval 0    //使用擦拭次数
STAT touch_hits 0    //touch命令未命中次数
STAT touch_misses 0    //touch命令命中次数
STAT auth_cmds 0    //认证命令处理的次数
STAT auth_errors 0    //认证失败数目
STAT bytes_read 545701515844        //总读取字节数（请求字节数）
STAT bytes_written 1649639749866    //总发送字节数（结果字节数）
STAT limit_maxbytes 2147483648        //分配给memcache的内存大小（字节）
STAT accepting_conns 1            //服务器是否达到过最大连接（0/1）
STAT listen_disabled_num 0    //失效的监听数
STAT threads 4        //当前线程数
STAT conn_yields 14    //连接操作主动放弃数目
STAT hash_power_level 16    //
STAT hash_bytes 524288
STAT hash_is_expanding 0
STAT expired_unfetched 30705763
STAT evicted_unfetched 0
STAT bytes 61380700    //当前存储占用的字节数
STAT curr_items 28786    //当前存储的数据总数
STAT total_items 75441133    //启动以来存储的数据总数
STAT evictions 0    //为获取空闲内存而删除的items数（分配给memcache的空间用满后需要删除旧的items来得到空间分配给新的items)
STAT reclaimed 39957976    //已过期的数据条目来存储新数据的数目
END

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

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

Java客户端

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

• spymemcached客户端

示例代码，如下所示：

package org.shirdrn.spymemcached;
import net.spy.memcached.AddrUtil;
import net.spy.memcached.BinaryConnectionFactory;
import net.spy.memcached.MemcachedClient;
import net.spy.memcached.internal.OperationFuture;
public class TestSpymemcached {
     public static void main(String[] args) throws Exception {
          String address = "192.168.4.86:11211";
          MemcachedClient client = new MemcachedClient(new BinaryConnectionFactory(),
                    AddrUtil.getAddresses(address));
          String key = "magic_words";
          int exp = 3600;
          String o = "hello";
          // set
          OperationFuture setFuture = client.set(key, exp, o);
          if(setFuture.get()) {
               // get
               System.out.println(client.get(key));
               // append
               client.append(key, " the world!");
               System.out.println(client.get(key));
               // prepend
               client.prepend(key, "Stone, ");
               System.out.println(client.get(key));
               // replace
               o = "This is a test for spymemcached.";
               OperationFuture replaceFuture = client.replace(key, exp, o);
               if(replaceFuture.get()) {
                    System.out.println(client.get(key));
                    // delete
                    client.delete(key);
                    System.out.println(client.get(key));
               }
          }
          client.shutdown();
     }
}

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

• XMemcached客户端

示例代码，如下所示：

package org.shirdrn.xmemcached;
import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.net.InetSocketAddress;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicLong;
import net.rubyeye.xmemcached.CASOperation;
import net.rubyeye.xmemcached.GetsResponse;
import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.command.BinaryCommandFactory;
import net.rubyeye.xmemcached.exception.MemcachedException;
import net.rubyeye.xmemcached.utils.AddrUtil;
public class UsingXMemcachedClient {
     public static void main(String[] args) throws IOException {
          String servers = "192.168.4.86:11211";
          // build and create a client
          XMemcachedClientBuilder builder = new XMemcachedClientBuilder(
                    AddrUtil.getAddresses(servers));
          builder.setCommandFactory(new BinaryCommandFactory());
          final MemcachedClient client = builder.build();
          // examples using client to operate
          final String key = "ghost";
          try {
               // add
               client.add(key, 0, "Ghost wind blows!");
               System.out.println("add & get: " + client.get(key));
               // append
               client.append(key, " It's a lie.");
               System.out.println("append & get: " + client.get(key));
               // prepend
               client.prepend(key, "Who's said?! ");
               System.out.println("prepend & get: " + client.get(key));
               // replace
               client.replace(key, 0, "Everything is nothing!");
               System.out.println("replace & get: " + client.get(key));
               // delete
               client.delete(key);
               System.out.println("delete & get: " + client.get(key));
               // gets
               List keys = Arrays.asList(new String[] {
                         "key1", "key2", "key3"
               });
               for(String k : keys) {
                    client.set(k, 3600, "v:" + System.nanoTime());
               }
               Map> values = client.gets(keys);
               for(Map.Entry> entry : values.entrySet()) {
                    System.out.println("key=" + entry.getKey() + ", value=" + entry.getValue().getValue());
               }
               // cas
               final AtomicLong seq = new AtomicLong(System.nanoTime());
               ExecutorService pool = Executors.newCachedThreadPool();
               for(int i=0; io: " + o);
                                   try {
                                        client.set(key, 0, o);
                                        Thread.sleep(100);
                                   } catch (TimeoutException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                   } catch (InterruptedException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                   } catch (MemcachedException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                   }
                              }
                         }
                    });
               }
               Thread.sleep(3000);
               for(int i=0; i() {
                         @Override
                         public int getMaxTries() {
                              return 3;
                         }
                         @Override
                         public CacheResult getNewValue(long arg0, CacheResult result) {
                              CacheResult old = result;
                              CacheResult nu = new CacheResult();
                              nu.file = old.file;
                              nu.lastmodified = seq.incrementAndGet();
                              System.out.println("cas: old=" + old + ", new=" + nu);
                              return result;
                         }
                    });
               }
               pool.shutdown();
               // flush_all
              client.flushAll();
               // stats
               List addresses = AddrUtil.getAddresses(servers);
               for(InetSocketAddress addr : addresses) {
                    Map stats = client.stats(addr);
                    System.out.println(stats);
               }
          } catch (TimeoutException e) {
               e.printStackTrace();
          } catch (InterruptedException e) {
               e.printStackTrace();
          } catch (MemcachedException e) {
               e.printStackTrace();
          }
          synchronized(client) {
               try {
                    client.wait();
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
          }
     }
     static class CacheResult implements Serializable {
          private static final long serialVersionUID = 3349686173080590047L;
          private File file;
          private long lastmodified;
          @Override
          public String toString() {
               return "file=[" + file + ", lastmodified=" + lastmodified + "]";
          }
     }
}

Node.js客户端

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

#!/usr/bin/env node
var MemcachedClient = require('memcached');
// configure memcached client
var servers = ['192.168.4.86:11211'];
var client = new MemcachedClient(servers);
// access memcached servers
var key = 'ghost';
// set
var value = 'Ghost wind blows!';
client.set(key, 0, value, function(err) {
     var data = 'key=' + key + ', value=' + value;
     if(err) {
          console.error('Fail to set: ' + data);
     } else {
          console.log('Added: ' + data);
     }
});
// get
var valueGot = client.get(key, function(err, data) {
     var dataGot = 'key=' + key + ', valueGot=' + data;
     if(err) {
                console.error('Fail to get: ' + dataGot);
        } else {
                console.log('Got: ' + dataGot);
        }
});

参考链接

• http://www.memcached.org
• https://code.google.com/p/memcached/wiki/NewStart
• http://www.memcached.org/files/memcached-1.4.20.tar.gz
• https://code.google.com/p/memcached/wiki/Clients
• https://github.com/downloads/libevent/
• https://github.com/downloads/libevent/libevent/libevent-1.4.14b-stable.tar.gz
• https://code.google.com/p/spymemcached/
• https://code.google.com/p/xmemcached/
• https://github.com/killme2008/xmemcached
• https://code.google.com/p/memcached/wiki/NewCommands
• http://www.2cto.com/os/201303/193264.html
• http://tech.idv2.com/tag/memcached/
• http://programcreek.com/java-api-examples/index.php?api=net.spy.memcached.MemcachedClient
• http://lzone.de/articles/memcached.htm
• http://blog.elijaa.org/?post/2010/05/21/Memcached-telnet-command-summary
• https://github.com/3rd-Eden/node-memcached
• https://www.npmjs.org/package/memcached

原文地址：Memcached服务器安装、配置、使用详解, 感谢原作者分享。