Memcache CAS协议介绍及使用

╰半橙微兮° 2022-08-07 08:47 38阅读 0赞

**1.什么是CAS**  
所谓CAS，check and set，在写操作时，先检查是否被别的线程修改过。  
基本原理非常简单，一言以蔽之，就是“版本号”。每个存储的数据对象，多有一个版本号。我们可以从下面的例子来理解：  
如果不采用CAS，则有如下的情景：  
第一步，A取出数据对象X；  
第二步，B取出数据对象X；  
第三步，B修改数据对象X，并将其放入缓存；  
第四步，A修改数据对象X，并将其放入缓存。  
我们可以发现，第四步中会产生数据写入冲突。  
  
如果采用CAS协议，则是如下的情景。  
第一步，A取出数据对象X，并获取到CAS-ID1；  
第二步，B取出数据对象X，并获取到CAS-ID2；  
第三步，B修改数据对象X，在写入缓存前，检查CAS-ID与缓存空间中该数据的CAS-ID是否一致。结果是“一致”，就将修改后的带有CAS-ID2的X写入到缓存。  
第四步，A修改数据对象Y，在写入缓存前，检查CAS-ID与缓存空间中该数据的CAS-ID是否一致。结果是“不一致”，则拒绝写入，返回存储失败。  
这样CAS协议就用了“版本号”的思想，解决了冲突问题。  
参考：[http://blog.csdn.net/poechant/article/details/7082189][http_blog.csdn.net_poechant_article_details_7082189]

**2.非CAS，模拟多客户端并发场景**

package cn.slimsmart.memcache.demo.test.cas;
    
    import java.net.InetSocketAddress;
    
    import net.spy.memcached.MemcachedClient;
    import net.spy.memcached.internal.OperationFuture;
    
    /**
     * 非cas测试
     */
    public class NoCASTest {
    	
    	public static void main(String[] args) throws Exception{
    		MemcachedClient cache = new MemcachedClient(new InetSocketAddress("192.168.100.110", 11211)); 
    		cache.set("key", 1800, "key");
    		new MThread("thread--1", "X").start();
    		new MThread("thread--2","Y").start();
    	}
    }
    
    class MThread extends Thread {
    	private MemcachedClient cache;
    	private String value;
    	
    	public MThread(String name,String value) throws Exception{
    		super(name);
    		cache = new MemcachedClient(new InetSocketAddress("192.168.100.110", 11211)); 
    		this.value=value;
    	}
    
    	@Override
    	public void run() {
    		OperationFuture<Boolean> future = cache.set("key", 1800, value);
    		System.out.println(Thread.currentThread().getName()+":"+future.getStatus());
    		try {
    			Thread.sleep(1000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println(Thread.currentThread().getName()+":"+cache.get("key"));
    	}
    }

运行结果，时而分会X，时而分会Y，也可以为key，不定的结果。  
  
**3.CAS 多线程使用场景**

package cn.slimsmart.memcache.demo.test.cas;
    
    import java.net.InetSocketAddress;
    
    import net.spy.memcached.CASResponse;
    import net.spy.memcached.CASValue;
    import net.spy.memcached.MemcachedClient;
    
    /**
     * cas测试
     */
    public class CASTest {
    
    	public static void main(String[] args) throws Exception {
    		MemcachedClient cache = new MemcachedClient(new InetSocketAddress("192.168.100.110", 11211));
    		cache.set("number", 1800, "number");
    		for (int i = 0; i < 2; i++) {
    			new CASThread("thread--" + i, "number" + i).start();
    		}
    	}
    }
    
    class CASThread extends Thread {
    	private MemcachedClient cache;
    	private String value;
    
    	public CASThread(String name, String value) throws Exception {
    		super(name);
    		cache = new MemcachedClient(new InetSocketAddress("192.168.100.110", 11211));
    		this.value = value;
    	}
    
    	@Override
    	public void run() {
    		int i = 0;
    		while (i < 5) {
    			i++;
    			CASValue<Object> uniqueValue = cache.gets("number");
    			CASResponse response = cache.cas("number", uniqueValue.getCas(), value);
    			if (response.toString().equals("OK")) {
    				System.out.println(Thread.currentThread().getName() + " update success:"+response);
    			}else{
    				System.out.println(Thread.currentThread().getName() + " update fail:"+response);
    			}
    		}
    	}
    }

**4.异步实时读写问题的解决方案SAC**  
当写入缓存后，如果立刻就有其他客户端进行读操作，则会读取失败，因为set是异步操作（async），很可能仍还没有写入完。  
MemcachedClient cache = new MemcachedClient(cacheServerAddr);    
cache.set("key", 3600, bigData);    
return cache.get("key");  
一种可行的方法，是采用同步写操作。常用的set方法没有这种方式，需要采用遵守Memcached的CAS（Check And Set）协议的写操作。而这种写操作，一般是基于读取后得到CAS ID（类似于SVN中的版本ID），根据这个CAS ID来保证写入时，没有和其他写入操作产生“写重复”冲突。因此，在我们现在所讨论的场景中，可以如下使用CAS协议：  
（1）初始写入：写一个简单的初始值（set，异步操作）；  
（2）获取版本：使用异步方式获取CAS ID；  
（3）同步写入：以同步方式写入数据，保证在读取前，已经写入结束。  
MemcachedClient cache = new MemcachedClient(cacheServerAddr);    
cache.set("key", 3600, "");    
long casId = cache.asyncGets("key").get().getCas();    
cache.cas("key", casid, bigData);    
return cache.get("key");   
以这种“Set-Asyncgets-Cas”方式的缓存异步实时读写问题的解决方案，我们称之为"SAC"。

[http_blog.csdn.net_poechant_article_details_7082189]: http://blog.csdn.net/poechant/article/details/7082189