memcached基本配置與使用

時間  2019-11-17
標籤 memcached 基本 配置 使用 欄目 Memcached 简体版
原文   原文鏈接

1、概念html

Memcached是danga.com開發的一套分佈式內存對象緩存系統，用於在動態系統中減小數據庫負載，提高性能。java


2、原理mysql

Memcached有兩個核心組件組成：服務端（ms）和客戶端（mc）。首先mc拿到ms列表，並對key作hash轉化，根據hash值肯定kv對所存的ms位置。而後在一個memcached的查詢中，mc先經過計算key的hash值來肯定kv對所處在的ms位置。當ms肯定後，客戶端就會發送一個查詢請求給對應的ms，讓它來查找確切的數據。由於ms之間並無護衛備份，也就不須要互相通訊，因此效率較高。
c++



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阿里軟件的架構師岑文初進行封裝的。裏面的註釋都是中文的，比較好
spring


5、服務器端sql

安裝數據庫

這裏介紹windows環境的安裝。
1.下載memcache的windows穩定版，解壓放某個盤下面，好比在c:\memcached
2.在cmd下輸入 'c:\memcached\memcached.exe -d install' 安裝
3.再輸入： 'c:\memcached\memcached.exe -d start' 啓動。
之後memcached將做爲windows的一個服務每次開機時自動啓動。這樣服務器端已經安裝完畢了。windows

內存分配api

默認狀況下，ms是用一個內置的叫「塊分配器」的組件來分配內存的。捨棄c++標準的malloc/free的內存分配，而採用塊分配器的主要目的 是爲了不內存碎片，不然操做系統要花費更多時間來查找這些邏輯上連續的內存塊（其實是斷開的）。用了塊分配器，ms會輪流的對內存進行大塊的分配，並 不斷重用。固然因爲塊的大小各不相同，當數據大小和塊大小不太相符的狀況下，仍是有可能致使內存的浪費。

同時，ms對key和data都有相應的限制，key的長度不能超過250字節，data也不能超過塊大小的限制 --- 1MB。
由於 mc所使用的hash算法，並不會考慮到每一個ms的內存大小。理論上mc會分配機率上等量的kv對給每一個ms，這樣若是每一個ms的內存都不太同樣，那可能 會致使內存使用率的下降。因此一種替代的解決方案是，根據每一個ms的內存大小，找出他們的最大公約數，而後在每一個ms上開n個容量=最大公約數的 instance，這樣就等於擁有了多個容量大小同樣的子ms，從而提供總體的內存使用率。

緩存策略

當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真實項目中的應用http://blog.csdn.net/sup_heaven/article/details/32728477


參考文章：

http://snowolf.iteye.com/blog/1471805

http://my249645546.iteye.com/blog/1420061

http://blog.csdn.NET/loujinhe/article/details/8491673?reload

http://hzp.iteye.com/blog/1872664

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程