总结下Memcached

时间  2019-12-07 标签 总结 memcached

 

memcached基本配置与使用

分类： MemCached 2

1、概念html

Memcached是danga.com开发的一套分布式内存对象缓存系统，用于在动态系统中减小数据库负载，提高性能。java


Memcached处理的原子是每个（key，value）对（如下简称kv对），c++

key会经过一个hash算法转化成hash-key，便于查找、对比以及作到尽量的散列[其实就是散列在多台不一样的服务器上]算法

同时，memcached用的是一个二级散列，经过一张大hash表来维护。
spring


2、原理数据库


Memcached有两个核心组件组成：服务端（ms）和客户端（mc）。windows

step1.首先mc客户端拿到ms列表，api

step2.并对key作hash转化，根据hash值肯定kv对所存的ms位置。【先是保存】缓存


step3.而后在一个memcached的查询中，mc先经过计算key的hash值来肯定kv对所处在的ms位置。服务器

step4.当ms肯定后，客户端就会发送一个查询请求给对应的ms，让它来查找确切的数据。【这里是查询】


由于ms之间并无护卫备份，也就不须要互相通讯，因此效率较高。



3、适用场合
1.分布式应用。因为memcached自己基于分布式的系统，因此尤为适合大型的分布式系统。
2.数据库前段缓存。数据库经常是网站系统的瓶颈。数据库的大并发量访问，经常形成网站内存溢出。固然咱们也可使用Hibernate的缓存机制。但memcached是基于分布式的，并可独立于网站应用自己，因此更适合大型网站进行应用的拆分。
3.服务器间数据共享。举例来说，咱们将网站的登陆系统、查询系统拆分为两个应用，放在不一样的服务器上，并进行集群，那这个时候用户登陆后，登陆信息如何从登陆系统服务器同步到查询系统服务器呢？这时候，咱们即可以使用memcached，登陆系统将登陆信息缓存起来，查询系统即可以得到登陆信息，就像获取本地信息同样。

4、客户端版本

Memcached Client目前有一下四种：
Memcached Client for Java，比 SpyMemcached更稳定、更早、更普遍；
SpyMemcached，比 Memcached Client for Java更高效；
XMemcached，比 SpyMemcache并发效果更好。 
alisoft-xplatform-asf-cache阿里软件的架构师岑文初进行封装的。里面的注释都是中文的，比较好


5、服务器端

安装

这里介绍windows环境的安装。
1.下载memcache的windows稳定版，解压放某个盘下面，好比在c:\memcached
2.在cmd下输入 'c:\memcached\memcached.exe -d install' 安装
3.再输入： 'c:\memcached\memcached.exe -d start' 启动。
之后memcached将做为windows的一个服务每次开机时自动启动。这样服务器端已经安装完毕了。

内存分配

默认状况下，ms是用一个内置的叫“块分配器”的组件来分配内存的。舍弃c++标准的malloc/free的内存分配，而采用块分配器的主要目的 是为了避免内存碎片，不然操做系统要花费更多时间来查找这些逻辑上连续的内存块（其实是断开的）。

用了块分配器，ms会轮流的对内存进行大块的分配，并 不断重用。固然因为块的大小各不相同，当数据大小和块大小不太相符的状况下，仍是有可能致使内存的浪费。

同时，ms对key和data都有相应的限制，

key的长度不能超过250字节，data也不能超过块大小的限制 --- 1MB。


由于 mc客户端所使用hash算法，并不会考虑到每一个ms服务端的内存大小。

理论上mc会分配几率上等量的kv对给每一个ms，这样若是每一个ms的内存都不太同样，那可能 会致使内存使用率的下降。


因此一种替代的解决方案是，根据每一个ms服务端的内存大小，找出他们的最大公约数，而后在每一个ms服务端上开n个容量=最大公约数的 instance，这样就等于拥有了多个容量大小同样的子ms，从而提供总体的内存使用率。

好比：

memcached服务器1：500M

Memcached服务器2：1500M

Memcached服务器3：2000M


最大公约数为500，

memcached服务器1创建(500/500)1个instance

memcached服务器2创建(1500/500)3个instance

memcached服务器3创建(2000/500)4个instance



缓存策略

当ms的hash表满了以后，新的插入数据会替代老的数据，更新的策略是LRU（最近最少使用），以及每一个kv对的有效时限。Kv对存储有效时限是在mc端由app设置并做为参数传给ms的。

同时ms采用是偷懒替代法，ms不会开额外的进程来实时监测过期的kv对并删除，而是当且仅当，新来一个插入的数据，而此时又没有多余的空间放了，才会进行清除动做。


6、范例

1.加载commons-pool-1.5.6.jar、java_memcached-release_2.6.6.jar、slf4j-api-1.6.1.jar、slf4j-simple-1.6.1.jar

2.建立memcached工具类：

[java]  view plain copy 在CODE上查看代码片 派生到个人代码片
  1. public class MemcachedUtil {  
  2.   
  3.     /** 
  4.      * memcached客户端单例 
  5.      */  
  6.     private static MemCachedClient cachedClient = new MemCachedClient();  
  7.       
  8.     /** 
  9.      * 初始化链接池 
  10.      */  
  11.     static {  
  12.         //获取链接池的实例  
  13.         SockIOPool pool = SockIOPool.getInstance();  
  14.           
  15.         //服务器列表及其权重  
  16.         String[] servers = {"127.0.0.1:11211"};  
  17.         Integer[] weights = {3};  
  18.           
  19.         //设置服务器信息  
  20.         pool.setServers(servers);  
  21.         pool.setWeights(weights);  
  22.           
  23.         //设置初始链接数、最小链接数、最大链接数、最大处理时间  
  24.         pool.setInitConn(10);  
  25.         pool.setMinConn(10);  
  26.         pool.setMaxConn(1000);  
  27.         pool.setMaxIdle(1000*60*60);  
  28.           
  29.         //设置链接池守护线程的睡眠时间  
  30.         pool.setMaintSleep(60);  
  31.           
  32.         //设置TCP参数，链接超时  
  33.         pool.setNagle(false);  
  34.         pool.setSocketTO(60);  
  35.         pool.setSocketConnectTO(0);  
  36.           
  37.         //初始化并启动链接池  
  38.         pool.initialize();  
  39.           
  40.         //压缩设置，超过指定大小的都压缩  
  41. //      cachedClient.setCompressEnable(true);  
  42. //      cachedClient.setCompressThreshold(1024*1024);  
  43.     }  
  44.       
  45.     private MemcachedUtil(){  
  46.     }  
  47.       
  48.     public static boolean add(String key, Object value) {  
  49.         return cachedClient.add(key, value);  
  50.     }  
  51.       
  52.     public static boolean add(String key, Object value, Integer expire) {  
  53.         return cachedClient.add(key, value, expire);  
  54.     }  
  55.       
  56.     public static boolean put(String key, Object value) {  
  57.         return cachedClient.set(key, value);  
  58.     }  
  59.       
  60.     public static boolean put(String key, Object value, Integer expire) {  
  61.         return cachedClient.set(key, value, expire);  
  62.     }  
  63.       
  64.     public static boolean replace(String key, Object value) {  
  65.         return cachedClient.replace(key, value);  
  66.     }  
  67.       
  68.     public static boolean replace(String key, Object value, Integer expire) {  
  69.         return cachedClient.replace(key, value, expire);  
  70.     }  
  71.       
  72.     public static Object get(String key) {  
  73.         return cachedClient.get(key);  
  74.     }  
  75.       
  76. }  
3. 建立须要缓存的对象：

[java]  view plain copy 在CODE上查看代码片 派生到个人代码片
  1. public class UserBean implements Serializable {  
  2.   
  3.     private static final long serialVersionUID = 9174194101246733501L;  
  4.   
  5.     private String username;  
  6.       
  7.     private String password;  
  8.       
  9.     public UserBean(String username, String password) {  
  10.         this.username = username;  
  11.         this.password = password;  
  12.     }  
  13.       
  14.     public String getUsername() {  
  15.         return username;  
  16.     }  
  17.       
  18.     public void setUsername(String username) {  
  19.         this.username = username;  
  20.     }  
  21.       
  22.     public String getPassword() {  
  23.         return password;  
  24.     }  
  25.       
  26.     public void setPassword(String password) {  
  27.         this.password = password;  
  28.     }  
  29.       
  30.     @Override  
  31.     public int hashCode() {  
  32.         final int prime = 31;  
  33.         int result = 1;  
  34.         result = prime * result  
  35.                 + ((password == null) ? 0 : password.hashCode());  
  36.         result = prime * result  
  37.                 + ((username == null) ? 0 : username.hashCode());  
  38.         return result;  
  39.     }  
  40.   
  41.     @Override  
  42.     public boolean equals(Object obj) {  
  43.         if (this == obj)  
  44.             return true;  
  45.         if (obj == null)  
  46.             return false;  
  47.         if (getClass() != obj.getClass())  
  48.             return false;  
  49.         UserBean other = (UserBean) obj;  
  50.         if (password == null) {  
  51.             if (other.password != null)  
  52.                 return false;  
  53.         } else if (!password.equals(other.password))  
  54.             return false;  
  55.         if (username == null) {  
  56.             if (other.username != null)  
  57.                 return false;  
  58.         } else if (!username.equals(other.username))  
  59.             return false;  
  60.         return true;  
  61.     }  
  62.   
  63.     @Override  
  64.     public String toString() {  
  65.         return "username:" + username + ",password:" + password;  
  66.     }  
  67. }  
4.建立测试用例：

[java]  view plain copy 在CODE上查看代码片 派生到个人代码片
  1. public class MemcachedUtilTest {  
  2.   
  3.     @Test  
  4.     public void testMemcached() {  
  5.         MemcachedUtil.put("hello", "world", 60);  
  6.         String hello = (String) MemcachedUtil.get("hello");  
  7.         Assert.assertEquals("world", hello);  
  8.           
  9.         for(int i = 0; i < 10000000; ++i) {  
  10.             UserBean userBean = new UserBean("Jason" + i, "123456-" + i);  
  11.             MemcachedUtil.put("user" + i, userBean, 60);  
  12.             Object obj = MemcachedUtil.get("user" + i);  
  13.             Assert.assertEquals(userBean, obj);  
  14.         }  
  15.     }  
  16. }  

5.经过spring注入memcached：

[html]  view plain copy 在CODE上查看代码片 派生到个人代码片
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.            http://www.springframework.org/schema/beans/spring-beans.xsd">  
  6.   
  7.     <bean id="memcachedPool" class="com.danga.MemCached.SockIOPool"   
  8.         factory-method="getInstance" init-method="initialize">  
  9.         <constructor-arg>  
  10.             <value>neeaMemcachedPool</value>  
  11.         </constructor-arg>  
  12.         <property name="servers">  
  13.             <list>  
  14.                 <value>127.0.0.1:11211</value>  
  15.             </list>  
  16.         </property>  
  17.         <property name="initConn">  
  18.             <value>20</value>  
  19.         </property>  
  20.         <property name="minConn">  
  21.             <value>10</value>  
  22.         </property>  
  23.         <property name="maxConn">  
  24.             <value>50</value>  
  25.         </property>  
  26.         <property name="nagle">  
  27.             <value>false</value>  
  28.         </property>  
  29.         <property name="socketTO">  
  30.             <value>3000</value>  
  31.         </property>  
  32.     </bean>  
  33.     <bean id="memcachedClient" class="com.danga.MemCached.MemCachedClient">  
  34.         <constructor-arg>  
  35.             <value>neeaMemcachedPool</value>  
  36.         </constructor-arg>  
  37.     </bean>  
  38. </beans>  

6.建立测试用例：

[java]  view plain copy 在CODE上查看代码片 派生到个人代码片
  1. public class MemcachedSpringTest {  
  2.   
  3.     private MemCachedClient cachedClient;  
  4.       
  5.     @Before  
  6.     public void init() {  
  7.         ApplicationContext context = new ClassPathXmlApplicationContext("com/luo/config/beans.xml");  
  8.         cachedClient = (MemCachedClient)context.getBean("memcachedClient");  
  9.     }  
  10.       
  11.     @Test  
  12.     public void testMemcachedSpring() {  
  13.         UserBean user = new UserBean("luo", "hi");  
  14.         cachedClient.set("user", user);  
  15.         UserBean cachedBean = (UserBean)user;  
  16.         Assert.assertEquals(user, cachedBean);  
  17.     }  
  18. }  

7、注意点

第1、memcached是在服务器端的内存中缓存对象的，不是缓存或硬盘；

第2、memcached的pool能够关联多个server，

String[] servers = {"10.20.185.12:11001","10.20.185.25:11001"};  
Integer[] weights = {3,7};  

该配置表示

30%的缓存在放在第一台服务器，

70%的将放在第二台服务器

这样即可以充分利用不一样服务器的内存了；


第3、我最困惑的是client是如何获得相应的pool的，后然看了点源码才知道是这样的。

client是经过pool的name关联到某个pool的，上面的例子中在SockIOPool pool = SockIOPool.getInstance();  和MemCachedClient client=new MemCachedClient();虽然都没写poolName，但就是新建了一个”default“的pool，而后client关联到了这个”default“的pool。固然咱们在新建这两个对象时能够给定具体的poolName。


=============================memcached的命令行操做======================================================

  • set
  • add
  • replace
  • get
  • delete

前三个命令是用于操做存储在 memcached 中的键值对的标准修改命令。它们都很是简单易用，且都使用以下 所示的语法： 

command <key> <flags> <expiration time> <bytes>
<span style="background-color: rgb(240, 240, 240); font-family: Arial;"><value></span>

表 1 定义了 memcached 修改命令的参数和用法。


表 1. memcached 修改命令参数
参数 用法
key key 用于查找缓存值
flags 能够包括键值对的整型参数，客户机使用它存储关于键值对的额外信息
expiration time 在缓存中保存键值对的时间长度（以秒为单位，0 表示永远）
bytes 在缓存中存储的字节点
value 存储的值（始终位于第二行）

如今，咱们来看看这些命令的实际使用。


在本地计算机链接到memcached服务：

命令：telnet  182.64.325.68 11211 

进入dos界面


命令：get xyTags【这里的userId是xyTags】



命令：delete   userId 


命令：set userId 0 0 5【这里的userId是key，须要另起一行来写入value】




命令：add  userId 0 0 5 
仅当缓存中不存在键时，add 命令才会向缓存中添加一个键值对。若是缓存中已经存在键，则以前的值将仍然保持相同，而且您将得到响应NOT_STORED。

下面是使用 add 命令的标准交互：

set userId 0 0 5
12345
STORED

下一篇：memcached真实项目中的应用http://blog.csdn.net/sup_heaven/article/details/32728477

联系我们 沪ICP备13005482号-10