缓存服务器-Memcached

介绍-Memcached

对于c的使用时间并不长，只是觉得有必要记录一下使用的心得。大致功能
- 1.缓存数据在缓存服务器中
- 2.以KEY/value的方式存储在缓存服务器中
- 3.可以设置缓存的值得有效时间
- 4.缓存数据不能持久化
- 5.缓存的数据可以保证多个并发访问操作同一份数据的一致性问题

部署Memcached

在Window系统下，Memcached的安装非常方便，只需从以上给出的地址下载可执行软件然后运行memcached.exe –d install即可完成安装。在Linux等系统下，我们首先需要安装libevent，然后从获取源码，make && make install即可。默认情况下，Memcached的服务器启动程序会安装到/usr/local/bin目录下。在启动Memcached时，我们可以为其配置不同的启动参数。
1）-p Memcached的TCP监听端口，缺省配置为11211；
2）-U Memcached的UDP监听端口，缺省配置为11211，为0时表示关闭UDP监听；
3）-s Memcached监听的UNIX套接字路径；
4）-a 访问UNIX套接字的八进制掩码，缺省配置为0700；
5）-l 监听的服务器IP地址，默认为所有网卡；
6）-d 为Memcached服务器启动守护进程；
7）-r 最大core文件大小；
8）-u 运行Memcached的用户，如果当前为root的话需要使用此参数指定用户；
9）-m 分配给Memcached使用的内存数量，单位是MB；
10）-M 指示Memcached在内存用光的时候返回错误而不是使用LRU算法移除数据记录；
11）-c 最大并发连数，缺省配置为1024；
12）-v –vv –vvv 设定服务器端打印的消息的详细程度，其中-v仅打印错误和警告信息，-vv在-v的基础上还会打印客户端的命令和相应，-vvv在-vv的基础上还会打印内存状态转换信息；
13）-f 用于设置chunk大小的递增因子；
14）-n 最小的chunk大小，缺省配置为48个字节；
15）-t Memcached服务器使用的线程数，缺省配置为4个；
16）-L 尝试使用大内存页；
17）-R 每个事件的最大请求数，缺省配置为20个；
18）-C 禁用CAS，CAS模式会带来8个字节的冗余；

使用方法

（转载自-http://www.oschina.net/code/snippet_250396_9181）
package com.wzpmt;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;

public class MemCachedManager {
    // 创建全局的唯一实例
    protected static MemCachedClient mcc = new MemCachedClient();

    protected static MemCachedManager memCached = new MemCachedManager();

    // 设置与缓存服务器的连接池
    static {
        // 服务器列表和其权重
        String[] servers = { "127.0.0.1:11211" };
        Integer[] weights = { 3 };

        // 获取socke连接池的实例对象
        SockIOPool pool = SockIOPool.getInstance();

        // 设置服务器信息
        pool.setServers( servers );
        pool.setWeights( weights );

        // 设置初始连接数、最小和最大连接数以及最大处理时间
        pool.setInitConn( 5 );
        pool.setMinConn( 5 );
        pool.setMaxConn( 250 );
        pool.setMaxIdle( 1000 * 60 * 60 * 6 );

        // 设置主线程的睡眠时间
        pool.setMaintSleep( 30 );

        // 设置TCP的参数，连接超时等
        pool.setNagle( false );
        pool.setSocketTO( 3000 );
        pool.setSocketConnectTO( 0 );

        // 初始化连接池
        pool.initialize();

        // 压缩设置，超过指定大小（单位为K）的数据都会被压缩
        mcc.setCompressEnable( true );
        mcc.setCompressThreshold( 64 * 1024 );
    }

    /**
     * 保护型构造方法，不允许实例化！
     *
     */
    protected MemCachedManager()
    {

    }

    /**
     * 获取唯一实例.
     * @return
     */
    public static MemCachedManager getInstance()
    {
        return memCached;
    }

    /**
     * 添加一个指定的值到缓存中.
     * @param key
     * @param value
     * @return
     */
    public boolean add(String key, Object value)
    {
        return mcc.add(key, value);
    }

    public boolean add(String key, Object value, Date expiry)
    {
        return mcc.add(key, value, expiry);
    }

    public boolean replace(String key, Object value)
    {
        return mcc.replace(key, value);
    }

    public boolean replace(String key, Object value, Date expiry)
    {
        return mcc.replace(key, value, expiry);
    }

    /**
     * 根据指定的关键字获取对象.
     * @param key
     * @return
     */
    public Object get(String key)
    {
        return mcc.get(key);
    }

    public static void main(String[] args)
    {
        MemCachedManager cache = MemCachedManager.getInstance();
        long startDate=System.currentTimeMillis();
        for (int i = 0; i < 10000*1000; i++) {
            cache.add("test"+i , "中国");
        }
        long endDate=System.currentTimeMillis();

        long nowDate=(endDate-startDate)/1000;
        System.out.println(nowDate);
        System.out.print( " get value : " + cache.get( "test" ));
    }
}

个人总结

使用memcached的好处，不必说，自然是它能有效的缓解数据库的压力。有效的解决数据库的问题。而且是分布式的。能够抗住更多的压力。
而且部署简单，使用方便。
不过就使用中的不便之处讲一下：
1.缓存集合类数据的时候不方便。如果一旦集合类中的数据有一条数据内容发生改变，我们就需要删除这一整个缓存。从新从数据库读取数据再次做缓存。分页缓存也是同样的道理。（所以一般在程序中，只针对单个对象的数据做缓存）。
2.缓存数据变化时，一定要实时的同步删除缓存。所以在代码中，一定要高度保存警惕，要做好记录那些做了缓存，然后找出这些对应的记录的 修改点 和 删除点，在对应的点 做好删除缓存的操作。如果忘记了，那么就糟糕了，用户看到的数据和 数据中的数据不一致，是不是很糟糕的事情。
3.无法持久化的问题，有一次大白天的，缓存服务器机器无缘由的宕机了。然后数据库连接数 瞬间就达到的警告线。重启了缓存服务器之后，也是如此，因为缓存服务器缓存的值是放在缓存中。所以机器重启之后，数据就都丢了，只能再次缓存。
启动Memcached服务：

1.启动Memcache的服务器端：

/usr/local/bin/memcached -d -m 100 -u root -l 192.168.141.64 -p 11211 -c 1024 -P /tmp/memcached.pid

-d选项是启动一个守护进程，
-m是分配给Memcache使用的内存数量，单位是MB，我这里是10MB，
-u是运行Memcache的用户，我这里是root，
-l是监听的服务器IP地址，如果有多个地址的话，我这里指定了服务器的IP地址192.168.0.200，
-p是设置Memcache监听的端口，我这里设置了12000，最好是1024以上的端口，
-c选项是最大运行的并发连接数，默认是1024，我这里设置了256，按照你服务器的负载量来设定，
-P是设置保存Memcache的pid文件，我这里是保存在 /tmp/memcached.pid，

memcached启动参数

-p 指定端口号（默认11211）
-U UDP监听端口 (默认: 11211, 0 时关闭)
-s 用于监听的UNIX套接字路径（禁用网络支持）
-a UNIX套接字访问掩码，八进制数字（默认：0700）
-m 指定最大使用内存大小（默认64MB）
-t 线程数（默认4）

-l 绑定地址 (默认:所有都允许,无论内外网或者本机更换IP，有安全隐患，若设置为127.0.0.1就只能本机访问)
-d start 启动memcached服务
-d restart 重起memcached服务
-d stop|shutdown 关闭正在运行的memcached服务
-u 绑定使用指定用于运行进程 （只有root用户可以使用这个参数）
-P 将PID写入文件，这样可以使得后边进行快速进程终止, 需要与 -d 一起使用

-M 内存耗尽时返回错误，而不是删除项
-c 最大同时连接数，默认是1024
-f 块大小增长因子，默认是1.25
-n 最小分配空间，key+value+flags默认是48
-k 锁定所有内存页。注意你可以锁定的内存上限。

试图分配更多内存会失败的，所以留意启动守护进程时所用的用户可分配的内存上限。
（不是前面的 -u 参数；在sh下，使用命令”ulimit -S -l NUM_KB”来设置。）

-v 提示信息（在事件循环中打印错误/警告信息。）
-vv 详细信息（还打印客户端命令/响应）
-vvv 超详细信息（还打印内部状态的变化）
-h 打印这个帮助信息并退出。
-i 打印memcached和libevent的许可。

-L 尝试使用大内存页（如果可用的话）。提高内存页尺寸可以减少”页表缓冲（TLB）”丢失次数，提高运行效率。为了从操作系统获得大内存页，memcached会把全部数据项分配到一个大区块。

-D 使用 作为前缀和ID的分隔符。
这个用于按前缀获得状态报告。默认是”:”（冒号）。
如果指定了这个参数，则状态收集会自动开启；如果没指定，则需要用命令”stats detail on”来开启。

-R 每个连接可处理的最大请求数。
-C 禁用CAS。
-b 设置后台日志队列的长度（默认：1024）
-B 绑定协议 - 可能值：ascii,binary,auto（默认）
-I 重写每个数据页尺寸。调整数据项最大尺寸。

常用组合：
memcached -d -m 256 -c 2048 -p 11211 -u www -l 127.0.0.1

2.如果要结束Memcache进程，执行：

# kill `cat /tmp/memcached.pid`

也可以启动多个守护进程，不过端口不能重复。