Memcached旅终结

最新推荐文章于 2021-02-17 03:25:50 发布
最新推荐文章于 2021-02-17 03:25:50 发布
阅读量760 收藏
点赞数
分类专栏： cache Java 文章标签： Memcached cache 缓存 缓存系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lobalfly/article/details/24294963
版权
Java 同时被 2 个专栏收录
27 篇文章 0 订阅
订阅专栏
cache
4 篇文章 0 订阅
订阅专栏


1. 什么是CAS协议

很多中文的资料都不会告诉大家CAS的全称是什么，Google.com一下，CAS是什么？CAS是Check And Set的缩写。

2. CAS协议原文

http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt

3. CAS的基本原理

基本原理非常简单，一言以蔽之，就是“版本号”。每个存储的数据对象，多有一个版本号。我们可以从下面的例子来理解：

如果不采用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协议就用了“版本号”，解决了这个问题。

我们可以发现，第四步中会产生数据写入失败

1. 非CAS

首先看一个不是CAS的Memcached程序实例。

程序实例：

package com.sinosuperman.memcached; 
import java.io.IOException; 
import java.net.InetSocketAddress; 
import net.spy.memcached.MemcachedClient; 
public class Test { 
    public static void main(String[] args) throws IOException { 
        MemcachedClient cache = new MemcachedClient(new InetSocketAddress("127.0.0.1", 11211)); 
         
        cache.set("x", 1800, "Love"); 
 
        String obj1 = (String) cache.get("x"); 
        String obj2 = (String) cache.get("x"); 
        obj2 = "Michael"; 
         
        cache.set("x", 1800, obj2); 
        System.out.println("Non-CAS 2:\t" + obj2); 
        System.out.println("Non-CAS 1:\t" + obj1); 
    } 
} 
package com.sinosuperman.memcached;

import java.io.IOException;
import java.net.InetSocketAddress;

import net.spy.memcached.MemcachedClient;

public class Test {
 public static void main(String[] args) throws IOException {
  MemcachedClient cache = new MemcachedClient(new InetSocketAddress("127.0.0.1", 11211));
 
  cache.set("x", 1800, "Love");

  String obj1 = (String) cache.get("x");
  String obj2 = (String) cache.get("x");
  obj2 = "Michael";
 
  cache.set("x", 1800, obj2);
  System.out.println("Non-CAS 2:\t" + obj2);
  System.out.println("Non-CAS 1:\t" + obj1);
 }
}

运行结果：

2011-12-18 23:12:39.836 INFO net.spy.memcached.MemcachedConnection:  Added {QA sa=/127.0.0.1:11211, #Rops=0, #Wops=0, #iq=0, topRop=null, topWop=null, toWrite=0, interested=0} to connect queue 
2011-12-18 23:12:39.843 INFO net.spy.memcached.MemcachedConnection:  Connection state changed for ***
Non-CAS 2:  Michael 
Non-CAS 1:  Love 
2011-12-18 23:12:39.836 INFO net.spy.memcached.MemcachedConnection:  Added {QA sa=/127.0.0.1:11211, #Rops=0, #Wops=0, #iq=0, topRop=null, topWop=null, toWrite=0, interested=0} to connect queue
2011-12-18 23:12:39.843 INFO net.spy.memcached.MemcachedConnection:  Connection state changed for
Non-CAS 2: Michael
Non-CAS 1: Love

 

可见在多个Client操作时，一定会引起写不一致性的问题。


2. CAS

程序实例：

package com.sinosuperman.memcached; 
 
import java.io.IOException; 
import java.net.InetSocketAddress; 
 
import net.spy.memcached.CASValue; 
import net.spy.memcached.MemcachedClient; 
 
public class Test { 
    @SuppressWarnings("unchecked") 
    public static void main(String[] args) throws IOException { 
        MemcachedClient cache = new MemcachedClient(new InetSocketAddress("127.0.0.1", 11211)); 
         
        cache.set("y", 1800, "Love"); 
 
        CASValue casValue1 = cache.gets("y"); 
        CASValue casValue2 = cache.gets("y"); 
        cache.cas("y", casValue2.getCas(), casValue2.getValue()); 
         
        System.out.println("CAS 2:\t" + casValue2.getCas()); 
        System.out.println("Value 2:\t" + casValue2.getValue()); 
         
        System.out.println("CAS 1:\t" + casValue1.getCas()); 
        System.out.println("Value 1:\t" + casValue1.getValue()); 
    } 
} 
package com.sinosuperman.memcached;

import java.io.IOException;
import java.net.InetSocketAddress;

import net.spy.memcached.CASValue;
import net.spy.memcached.MemcachedClient;

public class Test {
 @SuppressWarnings("unchecked")
 public static void main(String[] args) throws IOException {
  MemcachedClient cache = new MemcachedClient(new InetSocketAddress("127.0.0.1", 11211));
 
  cache.set("y", 1800, "Love");

  CASValue casValue1 = cache.gets("y");
  CASValue casValue2 = cache.gets("y");
  cache.cas("y", casValue2.getCas(), casValue2.getValue());
 
  System.out.println("CAS 2:\t" + casValue2.getCas());
  System.out.println("Value 2:\t" + casValue2.getValue());
 
  System.out.println("CAS 1:\t" + casValue1.getCas());
  System.out.println("Value 1:\t" + casValue1.getValue());
 }
}

运行结果：

2011-12-18 23:07:14.528 INFO net.spy.memcached.MemcachedConnection:  Added {QA sa=/127.0.0.1:11211, #Rops=0, #Wops=0, #iq=0, topRop=null, topWop=null, toWrite=0, interested=0} to connect queue 
2011-12-18 23:07:14.541 INFO net.spy.memcached.MemcachedConnection:  Connection state changed for
CAS 2:  11 
Value 2:    Love 
CAS 1:  11 
Value 1:    Love

 

1. 源程序


package com.sinosuperman.memcached; 
 
import java.io.IOException; 
import java.net.InetSocketAddress; 
 
import net.spy.memcached.CASResponse; 
import net.spy.memcached.CASValue; 
import net.spy.memcached.MemcachedClient; 
 
 
public class Test { 
     
    private static MemcachedClient client = null; 
     
    static { 
        try { 
            client = new MemcachedClient(new InetSocketAddress("localhost", 11211)); 
        } catch (IOException o) { 
        } 
    } 
 
    public static void main(String[] args) throws Exception { 
         
        client.set("numberss", 1800, 1); 
         
        Test testObj = new Test(); 
        for (int i = 0; i < 10; i++) { 
            testObj.new ThreadTest("Thread-" + (i + 1)).start(); 
        } 
    } 
     
    private class ThreadTest extends Thread { 
         
        private  MemcachedClient client = null; 
        ThreadTest(String name) throws IOException { 
            super(name); 
            client = new MemcachedClient(new InetSocketAddress("localhost", 11211)); 
        } 
         
        public void run() { 
            int i = 0; 
            int success = 0; 
            while (i < 10) { 
                i++; 
                CASValue<Object> uniqueValue =client.gets("numberss"); 
                CASResponse response = client.cas("numberss",    
                 uniqueValue.getCas(), (Integer)uniqueValue.getValue() + 1); 
 
                if (response.toString().equals("OK")) { 
                    success++; 
                } 
                 
                if (i == 10) 
                System.out.println(Thread.currentThread().getName() + " " +  i  
                  + " time " + " update oldValue : " + uniqueValue.getValue()  
                  +  " , result : " + response); 
            } 
             
            if (success < 10) { 
                Count.incr(10 - success); 
                System.out.println("Test counter: " + Count.get()); 
            } 
        } 
    } 
     
    public static class Count { 
        private static int counter = 0; 
        public static void incr(int x) { 
            counter += x; 
        } 
        public static int get() { 
            return counter; 
        } 
    } 
} 
package com.sinosuperman.memcached;

import java.io.IOException;
import java.net.InetSocketAddress;

import net.spy.memcached.CASResponse;
import net.spy.memcached.CASValue;
import net.spy.memcached.MemcachedClient;


public class Test {
 
private static MemcachedClient client = null;
 
static {
  try {
   client = new MemcachedClient(new InetSocketAddress("localhost", 11211));
  } catch (IOException o) {
  }
 }

 public static void main(String[] args) throws Exception {
 
  client.set("numberss", 1800, 1);
 
  Test testObj = new Test();
  for (int i = 0; i < 10; i++) {
   testObj.new ThreadTest("Thread-" + (i + 1)).start();
  }
 }
 
private class ThreadTest extends Thread {
 
  private  MemcachedClient client = null;
  ThreadTest(String name) throws IOException {
   super(name);
   client = new MemcachedClient(new InetSocketAddress("localhost", 11211));
  }
 
  public void run() {
   int i = 0;
   int success = 0;
   while (i < 10) {
    i++;
    CASValue<Object> uniqueValue =client.gets("numberss");
    CASResponse response = client.cas("numberss",  
                 uniqueValue.getCas(), (Integer)uniqueValue.getValue() + 1);

    if (response.toString().equals("OK")) {
     success++;
    }
   
    if (i == 10)
    System.out.println(Thread.currentThread().getName() + " " +  i
                  + " time " + " update oldValue : " + uniqueValue.getValue()
                  +  " , result : " + response);
   }
  
   if (success < 10) {
    Count.incr(10 - success);
    System.out.println("Test counter: " + Count.get());
   }
  }
 }
 
public static class Count {
  private static int counter = 0;
  public static void incr(int x) {
   counter += x;
  }
  public static int get() {
   return counter;
  }
 }
}

 

2. 输出结果：

Thread-1 10 time  update oldValue : 14 , result : EXISTS 
Test counter: 6 
Thread-2 10 time  update oldValue : 14 , result : EXISTS 
Test counter: 15 
Thread-3 10 time  update oldValue : 17 , result : EXISTS 
Test counter: 22 
Thread-5 10 time  update oldValue : 17 , result : EXISTS 
Test counter: 27 
Thread-4 10 time  update oldValue : 20 , result : OK 
Test counter: 33 
Thread-8 10 time  update oldValue : 27 , result : OK 
Test counter: 36 
Thread-6 10 time  update oldValue : 28 , result : EXISTS 
Test counter: 43 
Thread-10 10 time  update oldValue : 31 , result : EXISTS 
Test counter: 52 
Thread-9 10 time  update oldValue : 31 , result : OK 
Test counter: 60 
Thread-7 10 time  update oldValue : 35 , result : OK 
Test counter: 65 
Thread-1 10 time  update oldValue : 14 , result : EXISTS
Test counter: 6
Thread-2 10 time  update oldValue : 14 , result : EXISTS
Test counter: 15
Thread-3 10 time  update oldValue : 17 , result : EXISTS
Test counter: 22
Thread-5 10 time  update oldValue : 17 , result : EXISTS
Test counter: 27
Thread-4 10 time  update oldValue : 20 , result : OK
Test counter: 33
Thread-8 10 time  update oldValue : 27 , result : OK
Test counter: 36
Thread-6 10 time  update oldValue : 28 , result : EXISTS
Test counter: 43
Thread-10 10 time  update oldValue : 31 , result : EXISTS
Test counter: 52
Thread-9 10 time  update oldValue : 31 , result : OK
Test counter: 60
Thread-7 10 time  update oldValue : 35 , result : OK
Test counter: 65

3. 分析

我们可以看到，未成功的次数最终为65，数据值最终为35，两者的和刚好是100，正好符合我们的实验结果预期。

1. Memcached是什么？

Memcached是分布式的内存对象缓存系统。


2. Memcached的基本数据结构是什么？
Memcached是基于Key/Value对的HashMap。每一对，都可以设定过期时间。


3. Memcached用什么实现？
服务端程序由C语言编写，客户端可以用任何语言编写。客户端通过Memcached协议与服务端通信。


4. Memcached特点
（1）无备份/冗余：
各Memcached节点的数据之间没有互相备份，一旦某个节点挂掉，缓存中的数据就会丢失。


5. 开发团队
Memcached由Danga Interactive开发。


6. 相关下载
（1）Memcached服务端程序
http://memcached.org/


（2）Memcached的客户端程序
http://code.google.com/p/memcached/wiki/Clients


（3）Memcached可视化管理系统（PHP和jQuery编写）


http://www.junopen.com/memadmin


7. 如何理解Memcached的分布式特点？

Memcached Server并不具有分布式特征，每个Server都是独立运行的，各Server之间不存在通信获知其他节点状态和数据备份的功能。那么Memcached为什么还是分布式的缓存系统呢？其实说到Memcached的分布式，是将Memcached Client结合在一起考虑的。具体的分布式策略，由Client实现。也就是说Memcached的分布式，不是系统层的，而是应用层的。

异步实时读写

在使用Memcached时，一般实时读写的场景并不多见。但多是Memcached写入后，在一定时间后才会有读操作。但是如果应用场景，是写入后瞬间即会有读操作呢？似乎没有什么特别之处，我们依然可以这样写：


注：此处使用的是spymemcached客户端。

MemcachedClient cache = new MemcachedClient(cacheServerAddr); 
cache.set("key", 3600, bigData); 
return cache.get("key"); 
MemcachedClient cache = new MemcachedClient(cacheServerAddr);
cache.set("key", 3600, bigData);
return cache.get("key");

如此写入缓存后，如果立刻就有其他客户端进行读操作，则会读取失败，因为set是异步操作（async），很可能仍还没有写入完。

一种可行的方法，是采用同步写操作。常用的set方法没有这种方式，需要采用遵守Memcached的CAS（Check And Set）协议的写操作。而这种写操作，一般是基于读取后得到CAS ID（类似于SVN中的版本ID），根据这个CAS ID来保证写入时，没有和其他写入操作产生“写重复”Conflict。因此，在我们现在所讨论的场景中，可以如下使用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"); 
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");


 

 

 

 

 

Memcached介绍和详解
weixin_44976692的博客
06-28 5万+
在现代的高性能网络应用中，缓存机制扮演着至关重要的角色。缓存不仅可以显著提高数据读取速度，还能减轻后端服务器的压力，从而提升整个系统的性能和响应速度。Memcached作为一种高效的分布式内存对象缓存系统，被广泛应用于各种场景中。本文将深入介绍Memcached的工作原理、架构设计、安装配置、使用方法以及在实际应用中的一些优化技巧。Memcached是一种高性能的分布式内存缓存系统，用于加速动态Web应用程序，通过缓存数据库查询结果、API调用结果和其他需要频繁访问的数据，从而减轻数据库和后端服务器的负载。
memcached的配置和spymemcached的使用笔记
小鸡也疯狂的Blog
02-06 6478
memcached的配置和spymemcached的使用笔记
跑着跑着，突然就卡了？ 卡着卡着，突然还挂了？
Kyligence
12-20 610
使用 Kylin 2.6.4 之前的版本并且以 Memcached 作为查询缓存时，即有概率触发 Memcached IO 线程死亡问题，本文作者为大家分享了如何通过实验一步步排查，找出问题根源，并通过非常简单的方式解决这一 bug 的过程。 前提条件 使用 Kylin 2.6.4 之前的版本并且使用 Memcached 作为查询缓存，即有概率触发该问题。 故障现象 K...
Memcached使用入门
冯辉
03-13 1028
下载Memcached的服务器端软件 Windows平台版本下载：http://splinedancer.com/memcached-win32/memcached-1.2.4-Win32-Preview-20080309_bin.zip Linux平台版本下载：http://memcached.googlecode.com/files/memcached-1.4.10.tar.gz
java验证码 memcache_在java中实现Memcache的错误
weixin_33696476的博客
02-17 421
我试图用Java写一个简单的代码来连接到一个memcache服务器。我使用spymemcached 2.8 jar，但我得到一个“服务器重新连接”错误，我无法理解。代码是：**client = new MemcachedClient(new BinaryConnectionFactory(),AddrUtil.getAddresses("127.0.0.1:11211"));} catch...
Memcached的CAS协议
maqianmaqian的专栏
06-12 139
Memcached于1.2.4版本新增CAS(Check and Set)协议类同于Java并发的CAS(Compare and Swap)原子操作，处理同一item被多个线程更改过程的并发问题。  基本原理非常简单，一言以蔽之，就是“版本号”。每个存储的数据对象，多有一个版本号。我们可以从下面的例子来理解： 如果不采用CAS，则有如下的情景： 第一步，A取出数据对象X； 第二步...
使用spymemcached spring整合的时候遇到的一个配置问题
caimoxuan的博客
04-13 3222
当使用spymemcached的时候，在windows下安装了memcached，telnet进入，测试之后写了一个java的测试类 public static void main(String args[])throws Exception{ MemcachedClient cache = new MemcachedClient(new InetSocketAddress("127
memcached
03-19
获取SecretID，SecretKey以及调用地址（端点），端点为memcached.tencentcloudapi.com，具体参考各产品说明。 获取安装 通过Composer安装 通过Composer获取安装是使用PHP SDK的推荐方法，Composer是PHP的依赖管理...
memcached 1.6.13
01-23
**标题：“memcached 1.6.13”** **描述：“windows x64 下可运行的 memcached 1.6.13，使用 MSYS2 编译”** **标签：“memcached 数据库 database memcache 缓存”** 本文将深入探讨 `memcached 1.6.13` 版本，...
memcached-1.5.4
12-22
**memcached-1.5.4源码分析与编译指南** `memcached`是一款高性能、分布式的内存对象缓存系统，广泛应用于Web应用中，用于减轻数据库负载，提高数据访问速度。它通过将数据存储在内存中，实现快速读取，避免了频繁...
windows下的memcached 1.6.21，并且做成了windows的服务
最新发布
07-07
在windows下编译的最新的memcached 1.6.21 由于1.4.5以后的memcached不支持windows服务。 使用第三方工具做成了windows的服务 使用说明： 1、解压rar文件 2、以管理员身份运行cmd.exe 3、然后执行service_install....
Memcached配置参数初解[转]
breezylee09的专栏
04-10 184
转:http://www.2cto.com/database/201201/117256.html   一、基本参数 在我们第一次安装Memcached时，一般都是用过这个命令： [plain] memcached -m 512 -u root -d -l 127.0.0.1 -p 11211    我们先来解释这几个参数的含义吧。   -m 指定缓存所使用的最大内存容量，单位是Megaby...
memcached client -- spymemcached使用
z69183787的专栏
10-25 2981
spymemcached是一个memcached的客户端 http://code.google.com/p/spymemcached/   测试代码如下： 1.SpyMemcachedConstants [java] view plain copy import java.util.concurrent.TimeUnit;      pu
实战Memcached缓存系统
jiubugeinifo的专栏
10-30 1965
1. What is Memcached? Memcached是一个免费开源、高性能、分布式的内存对象缓存系统。Memcached是在内存中，为特定数据（字符串或对象）构建key-value的小块数据存储。 2. 下载Memcached的服务器端软件 Windows平台版本下载：http://splinedancer.com/memcached-win32/memcached
Java连接并使用Memcached
WuTing的专栏
08-02 4236
如何连接Memcached并且实现新增，删除，替换，加减，追加字符串，保存对象
spring整合spymemcached实现Memcached的各种操作
零度的博客专栏
01-19 4055
1.配置pom.xml、web.xml、applicationContext.xml和servletmvc.xml,仅仅列出与memcached相关配置 pom.xml net.spy spymemcached 2.12.0   web.xml <web-app version="3.0" xmlns="http://
在Hibernate中使用Memcached作为一个二级分布式缓存
weixin_30670925的博客
06-19 121
转自：http://www.blogjava.net/xmatthew/archive/2008/08/20/223293.html hibernate-memcached--在Hibernate中使用Memcached作为一个二级分布式缓存 今天在网上看到一个用Memcached作为Hibernate二级分布式缓存，感觉挺有兴趣，就是尝试用了，感觉还不错，就推荐给大家看一下。官方网址:...
启动tomcat报"Closing, and reopening {QA sa=/127.0.0.1:11211, #Rops=0....."
冉木的博客
04-17 571
安装， memcached 1.4.5 版本安装为例： 1、解压下载的安装包到指定目录。 链接: https://pan.baidu.com/s/1jPALbw6K1d9aOIx9S_827Q 提取码: qmty 2、在 memcached1.4.5 版本之后，memcached 不能作为服务来运行，需要使用任务计划中来开启一个普通的进程，在 window 启动时设置 memcached自动执行...
优化之旅：MemCached Java客户端封装实践
"本文主要介绍了Memcached Cache Java Client的封装优化过程，作者通过分享自己的经验，探讨了Memcached的基本特性和优化策略。" 在Java开发中，Memcached作为一种高效的分布式内存缓存系统，被广泛应用于缓解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值