Memcached入门

Memcached是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。

它经过在内存中缓存数据和对象来减小读取数据库的次数，从而提供动态、数据库驱动网站的速度。

Memcached基于一个存储键值对的hashmap。其守护进程（daemon ）是用C写的，可是客户端能够用任何语言来编写，并经过memcached协议与守护进程通讯。

 

下面来了解下Memcached怎么用~~

1、准备工做

到http://code.jellycan.com/memcached/

下载memcached的windows版

再下载一个java_memcached-release.jar

 

2、安装

解压memcached-1.2.5-win32-bin.zip，CMD进入其目录，而后执行以下命令：

c:>memcached.exe -d install
c:>memcached.exe -l 127.0.0.1 -m 32 -d start

第一行是安装memcached成为服务，这样才能正常运行，不然运行失败！

第二行是启动memcached的，这里简单的只分配32M内存了(默认64M)，而后监听本机端口和以守护进行运行。

执行完毕后，咱们就能够在任务管理器中看到memcached.exe这个进程了。

若是想要在同一台Windows机器中安装2个Memcached，请看这里

3、使用

如今服务器已经正常运行了，下面咱们就来写java的客户端链接程序。

将java_memcached-release.zip解压，把java_memcached-release.jar文件复制到java项目的lib目录下，

而后咱们来编写代码，好比我提供的一个应用类以下：

package memcached.test;

import java.util.Date;

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

/**
 * 使用memcached的缓存实用类.
 */
public class MemCached {
    // 建立全局的惟一实例
    protected static MemCachedClient mcc = new MemCachedClient();

    protected static MemCached memCached = new MemCached();

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

        // 获取socke链接池的实例对象
        // 这个类用来建立管理客户端和服务器通信链接池，
        // 客户端主要的工做（包括数据通信、服务器定位、hash码生成等）都是由这个类完成的。
        SockIOPool pool = SockIOPool.getInstance();

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

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

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

        // 设置链接心跳监测开关
        // true:每次通讯都要进行链接是否有效的监测，形成通讯次数倍增，加大网络负载，
        // 所以在对HighAvailability要求比较高的场合应该设为true
        // 默认状态是false，建议保持默认。
        pool.setAliveCheck(false);

        // 设置链接失败恢复开关
        // 设置为true，当宕机的服务器启动或中断的网络链接后，这个socket链接还可继续使用，不然将再也不使用.
        // 默认状态是true，建议保持默认。
        pool.setFailback(true);

        // 设置容错开关
        // true:当当前socket不可用时，程序会自动查找可用链接并返回，不然返回NULL
        // 默认状态是true，建议保持默认。
        pool.setFailover(true);

        // 设置hash算法
        // alg=0 使用String.hashCode()得到hash code,该方法依赖JDK，可能和其余客户端不兼容，建议不使用
        // alg=1 使用original 兼容hash算法，兼容其余客户端
        // alg=2 使用CRC32兼容hash算法，兼容其余客户端，性能优于original算法
        // alg=3 使用MD5 hash算法
        // 采用前三种hash算法的时候，查找cache服务器使用余数方法。采用最后一种hash算法查找cache服务时使用consistent方法。
        // 默认值为0
        pool.setHashingAlg(0);

        // 设置是否使用Nagle算法，由于咱们的通信数据量一般都比较大（相对TCP控制数据）并且要求响应及时，
        // 所以该值须要设置为false（默认是true）
        pool.setNagle(false);
        
        // 设置socket的读取等待超时值
        pool.setSocketTO(3000);
        
        // 设置socket的链接等待超时值
        pool.setSocketConnectTO(0);

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

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

    private MemCached() {

    }

    /**
     * 获取惟一实例.
     * singleton
     * @return
     */
    public static MemCached getInstance() {
        return memCached;
    }

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

    /**
     * 添加一个指定的键值对到缓存中.
     * 
     * @param key
     * @param value
     * @param expiry 多久以后过时
     * @return
     */
    public boolean add(String key, Object value, Date expiry) {
        return mcc.add(key, value, expiry);
    }
    
    
    public boolean set(String key, Object value) {
        return mcc.set(key, value);
    }

    public boolean set(String key, Object value, Date expiry) {
        return mcc.set(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);
    }
}

MemCached

写个Main方法测试下：

    public static void main(String[] args) {
        MemCached cache = MemCached.getInstance();
        boolean result1 = cache.add("hello", 1234, new Date(1000 * 2));// 设置2秒后过时
        System.out.println("第一次add : " + result1);
        System.out.println("Value : " + cache.get("hello"));
        
        boolean result2 =cache.add("hello", 12345, new Date(1000 * 2));// add fail
        System.out.println("第二次add : " + result2);
        
        boolean result3 =cache.set("hello", 12345, new Date(1000 * 2));// set successes
        System.out.println("调用set : " + result3);
        
        System.out.println("Value : " + cache.get("hello"));

        try {
            Thread.sleep(1000 * 2);
            System.out.println("已经sleep2秒了....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Value : " + cache.get("hello"));
    }

执行结果以下：

第一次add : true
Value : 1234
第二次add : false
调用set : true
Value : 12345
已经sleep2秒了....
Value : null

说明：

1. 第二次add失败是由于"hello"这个key已经存在了。
2. 调用set成功，是由于set的时候覆盖了已存在的键值对，这正是add和set的不一样之处
3. 设置过时之间以后，cache按时自动失效

 

上面的例子是对于基本数据类型，对于普通的POJO而言，若是要进行存储的话，那么好比让其实现java.io.Serializable接口。

由于memcached是一个分布式的缓存服务器，多台服务器间进行数据共享须要将对象序列化的，因此必须实现该接口，不然会报错的（java.io.NotSerializableException）。

下面来试试POJO的存储：

package memcached.test;
public class Person implements java.io.Serializable {
    private static final long serialVersionUID = 1L;

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

简单的POJO对象

Main方法以下：

    public static void main(String[] args) {
        MemCached cache = MemCached.getInstance();

        Person p1 = new Person();
        p1.setName("Jack");
        cache.add("bean", p1);
        
        Person p2 = (Person) cache.get("bean");
        System.out.println("name=" + p2.getName());//Jack
        p2.setName("Rose");
        
        // cache.replace("bean", p2);
        Person p3 = (Person) cache.get("bean");
        System.out.println("name=" + p3.getName());
    }

上面的代码中，咱们经过p2.setName("Rose")修改了对象的名字，

最后一行打印的会是什么呢？

name=Jack
name=Jack

Why?

这是由于咱们修改的对象并非缓存中的对象，而是经过序列化过来的一个实例对象

那么要修改怎么办？使用replace，注释掉的那一行把注释去掉就能够了。

 

4、其余

Memcached的命令参数说明

-p <num>                监听的端口
-l <ip_addr>            链接的IP地址, 默认是本机
-d start                   启动memcached服务
-d restart                重起memcached服务
-d stop|shutdown    关闭正在运行的memcached服务
-d install                  安装memcached服务
-d uninstall              卸载memcached服务
-u <username>       以<username>的身份运行 (仅在以root运行的时候有效)
-m <num>              最大内存使用，单位MB。默认64MB
-M                          内存耗尽时返回错误，而不是删除项
-c <num>                最大同时链接数，默认是1024
-f <factor>              块大小增加因子，默认是1.25
-n <bytes>             最小分配空间，key+value+flags默认是48
-h                          显示帮助

 Memcached也能够在控制台中添加键值对，首先使用命令“telnet 127.0.0.1 11211”进入到Memcached控制台，

而后使用set、add、replace、get、delete来操做。

更详细操做可参照这里

 

5、Memcached的优点和不足

说到Memcached的优点，那固然是：速度快，操做简便，易扩展

不足的话，主要有2点：

1. 数据的临时性(数据仅保存在内存中)
2. 只能经过指定键来读取数据，不支持模糊查询

 

6、Memcached中止时的保障措施

若是数据库的访问量比较大，就须要提早作好准备，以便应对在memcached中止时发生的负载问题。

若是能在中止memcached以前，把数据复制到其余的server就行了。恩，这个能够经过repcached来实现。

repcached是日本人开发的实现memcached复制功能，
它是一个单master、单slave的方案，但它的master/slave都是可读写的，并且能够相互同步
若是master坏掉，slave侦测到链接断了，它会自动listen而成为master

 

 Memcached 集群架构方面的问题