Memcached 并发控制 CAS 协议

部分资料参考：http://langyu.iteye.com/blog/680052

Memcached于1.2.4版本新增CAS(Check and Set)协议类同于Java并发的CAS(Compare and Swap)原子操作，处理同一item被多个线程更改过程的并发问题。

在Memcached中，每个key关联有一个64-bit长度的long型惟一数值，表示该key对应value的版本号。这个数值由Memcached server产生，从1开始，且同一Memcached server不会重复。在两种情况下这个版本数值会加1：1、新增一个key-value对；2、对某已有key对应的value值更新成功。删除item版本值不会减小。

例如：

MemcachedClient client = new MemcachedClient();
   client.set("fKey", "fValue"); 
  //第一次set, 在Memcached server中会维护fKey对应的value的版本号，假设是548;

   client.set("fKey", "sValue"); 
  //再次set，则这个fKey对应的value的版本号变为549;

   CASValue casValue = client.gets("fKey");
  //这样就可以得到对应key的cas版本号和实际value(各个Memcached client都有类似的对象表示，名字可能不一样，但效果类同)，如 casValue.getValue = "sValue"，casValue.getCas=549;

CAS协议解决的问题

模拟多个Memcached client并发set同一个key的场景。如clientA想把当前key的value set为"x"，且操作成功；clientB却把当前key的value值由"x"覆盖set为"y"，这时clientA再根据key去取value时得到"y"而不是期望的"x"，它使用这个值，但不知道这个值已经被其它线程修改过，就可能会出现问题。

CAS协议解决这种并发修改问题。有线程试图修改当前key-value对的value时，先由gets方法得到item的版本号，操作完成提交数据时，使用cas方法谨慎变更，如果在本地对item操作过程中这个key-value对在Memcached server端被其它线程更改过，就放弃此次修改(乐观锁概念)。

CASValue casValue = client.gets(key);
//*****
//本地的各种处理
//*****
CASResponse response = client.cas(key, newValue, casValue);
//在我取数据时item的版本号是casValue.getCas()，所以提交时我期望item的版本号是没有改变过的。如果被修改过，不是我取数据时的版本号，那么Memcached server对这次提交什么也不做，返回true或false由用户自己来提出解决方案(什么也不做或是重新获取版本号，再次重试提交等)

并发环境下的正确性验证

测试场景：用2个Memcached client（C++、java客户端都可以）并发更改同一个key值，一个将value加1，一个将value减1，如果某次操作失败了（因为本次从读到改的过程中另一个进程修改了值），修改数值的操作失败，加1或减1操作暂时保存在一个变量中，等下次成功的时候一次性加上去或减掉，这样还是可以保证数据的正确性。下面我选的两个客户端程序分别是C++和java程序，当然两个都是C++和java的程序也是一样的

(memcached_get()方法获得到一个数据指针后，用完记得释放内存，否则会造成内存泄露：http://docs.libmemcached.org/memcached_get.html)

//============================================================================
// Name        : memcached_cpp.cpp
// Author      : 
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C, Ansi-style
//============================================================================

#include <libmemcached/memcached.h>
#include <vector>
#include <sys/msg.h>
#include <errno.h>
#include <string>
#include <iostream>
#include <sys/file.h>
#include <stdio.h>
#include <vector>
#include <sys/time.h>
#include<time.h>
#include <math.h>
#include<sstream>

using namespace std;

int q2alen=0;
int alertfd=0;


string numberToString(int d){
	std::stringstream ss;
	ss<<d;
	string str = ss.str();
	return str;
}


/*
 * @author: roger
 * @version: 2014-05-17 17:45:10
 *
 *libmemcached客户端的基本用法，增加，获取，删除数据
 */
int main() {

	memcached_st *memc;
	memcached_return rc;
	memcached_server_st *server;
	time_t expiration = 0 ;   //设置为0表示永不过期
	uint32_t flags =32 ;  //如果与java客户端混用，这个需要设置为32

	memc = memcached_create(NULL);
	server = memcached_server_list_append(NULL, "localhost", 11211, &rc);
	rc = memcached_server_push(memc, server);  //set，get方法都需要这个参数
	memcached_server_list_free(server);
	string value = "2";
	size_t value_length = value.length();   //get方法中并不知道value的长度，可填0
	size_t key_length ;

	rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);

	int num=1;

	string key = "dai";

	int i =0;
	while(i<10000){

		char * val = memcached_get(memc, key.c_str(), key.length(), &value_length,&flags, &rc);
//		cout<<memc->result.item_cas<<endl;

		int a = atoi(val);
		a = a-num;
		string val2 = numberToString(a);

		rc = memcached_cas(memc, key.c_str(), key.length(), val2.c_str(),val2.length(), expiration, flags,memc->result.item_cas);
		if (rc != MEMCACHED_SUCCESS) {
			num++; //一次没有成功，下次就减2了，依次类推
		}
		else{
			num = 1;//成功了，下次就是减1
		}

		i++;
	}



//	free，断开连接，释放资源，但未删除memcached中数据
	memcached_free(memc);
	return 0;
}

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

public class test2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MemCachedClient client=new MemCachedClient();
        String [] addr ={"localhost:11211"};    //ip、端口号
        Integer [] weights = {3};
        
        //SockIOPool是Memcached客户端提供的一个套接字连接池
        SockIOPool pool = SockIOPool.getInstance();  
        pool.setServers(addr);
        pool.setWeights(weights);  
        pool.setInitConn(5);  
        pool.setMinConn(5);  
        pool.setMaxConn(200);  
        pool.setMaxIdle(1000*60*60);  
        pool.setMaintSleep(30);  
        pool.setNagle(false);  
        pool.setSocketTO(30);  
        pool.setSocketConnectTO(0);  
        pool.initialize();
        
//        client.set("dai", "0");  //测试的初始化
        
//        int result = (Integer) client.get("dai");   	//检查结果
//        System.out.println(result);
        
        
        int num = 1;  //表示默认加1
        
        int a =0;
        while (a<10000) {
        	MemcachedItem item = client.gets("dai");
            String value = (String) item.getValue();
            long cas = item.getCasUnique();
            int value2 = Integer.valueOf(value)+num;
            
            boolean issuccess =client.cas("dai", String.valueOf(value2), cas);
            if (!issuccess) {
    			num++;  //一次没有成功，下次就加2了，依次类推
    		}
            else {
				num = 1;  //如果成功了，那每次还是只加1
			}
            
            a++;
		}
        
	}

}

两个程序同时运行，中间重叠的部分即为并发修改value的部分，也是我们测试的地方，运行结束发现memcached中的值仍然为0，表示并发控制成功。