ehcache、memcache、redis三大緩存比較

時間  2019-11-19
標籤 ehcache memcache redis 三大 緩存 比較 欄目 Memcached 简体版
原文   原文鏈接

最近項目組有用到這三個緩存，去各自的官方看了下,以爲還真的各有千秋！今天特地概括下各個緩存的優缺點，僅供參考！php

 Ehcachehtml

在Java項目普遍的使用。它是一個開源的、設計於提升在數據從RDBMS中取出來的高花費、高延遲採起的一種緩存方案。正由於Ehcache具備健壯性（基於java開發）、被認證（具備apache 2.0  license）、充滿特點（稍後會詳細介紹），因此被用於大型複雜分佈式web application的各個節點中。java

什麼特點？mysql


1.  夠快git

Ehcache的發行有一段時長了，通過幾年的努力和不可勝數的性能測試，Ehcache終被設計於large, high concurrency systems.github


2. 夠簡單web

開發者提供的接口很是簡單明瞭，從Ehcache的搭建到運用運行僅僅須要的是你寶貴的幾分鐘。其實不少開發者都不知道本身用在用Ehcache，Ehcache被普遍的運用於其餘的開源項目redis

好比：hibernate算法


3.夠袖珍sql

關於這點的特性，官方給了一個很可愛的名字small foot print ，通常Ehcache的發佈版本不會到2M，V 2.2.3  才 668KB。


4. 夠輕量

核心程序僅僅依賴slf4j這一個包，沒有之一！


5.好擴展

Ehcache提供了對大數據的內存和硬盤的存儲，最近版本容許多實例、保存對象高靈活性、提供LRU、LFU、FIFO淘汰算法，基礎屬性支持熱配置、支持的插件多


6.監聽器

緩存管理器監聽器 （CacheManagerListener）和 緩存監聽器（CacheEvenListener）,作一些統計或數據一致性廣播挺好用的

如何使用？

夠簡單就是Ehcache的一大特點，天然用起來just so easy!

貼一段基本使用代碼

CacheManager manager = CacheManager.newInstance("src/config/ehcache.xml");
Ehcache cache = new Cache("testCache", 5000, false, false, 5, 2);
cacheManager.addCache(cache);
  •        name:緩存名稱。
  •        maxElementsInMemory：緩存最大個數。
  •        eternal:對象是否永久有效，一但設置了，timeout將不起做用。
  •        timeToIdleSeconds：設置對象在失效前的容許閒置時間（單位：秒）。僅當eternal=false對象不是永久有效時使用，可選屬性，默認值是0，也就是可閒置時間無窮大。
  •        timeToLiveSeconds：設置對象在失效前容許存活時間,最大時間介於建立時間和失效時間之間。僅當eternal=false對象不是永久有效時使用，默認是0.，也就是對象存活時 間無窮大。
  •        overflowToDisk：當內存中對象數量達到maxElementsInMemory時，Ehcache將會對象寫到磁盤中。
  •        diskSpoolBufferSizeMB：這個參數設置DiskStore（磁盤緩存）的緩存區大小。默認是30MB。每一個Cache都應該有本身的一個緩衝區。
  •        maxElementsOnDisk：硬盤最大緩存個數。
  •        diskPersistent： 是否緩存虛擬機重啓期數 據 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
  •        diskExpiryThreadIntervalSeconds：磁盤失效線程運行時間間隔，默認是120秒。
  •        memoryStoreEvictionPolicy：當達到maxElementsInMemory限制時，Ehcache將會根據指定的策略去清理內存。默認策略是LRU。你能夠設置爲 FIFO或是LFU。
  •        clearOnFlush：內存數量最大時是否清除。

 

memcache

memcache 是一種高性能、分佈式對象緩存系統，最初設計於緩解動態網站數據庫加載數據的延遲性，你能夠把它想象成一個大的內存HashTable，就是一個key-value鍵值緩存。Danga Interactive爲了LiveJournal所發展的，以BSD license釋放的一套開放源代碼軟件。


1.依賴

memcache C語言所編寫，依賴於最近版本的GCC和libevent。GCC是它的編譯器，同事基於libevent作socket io。在安裝memcache時保證你的系統同事具有有這兩個環境。


2.多線程支持

memcache支持多個cpu同時工做，在memcache安裝文件下有個叫threads.txt中特別說明，By default, memcached is compiled as a single-threaded application.默認是單線程編譯安裝，若是你須要多線程則須要修改./configure --enable-threads，爲了支持多核系統，前提是你的系統必須具備多線程工做模式。開啓多線程工做的線程數默認是4，若是線程數超過cpu數 容易發生操做死鎖的機率。結合本身業務模式選擇才能作到物盡其用。


3.高性能

經過libevent完成socket 的通信，理論上性能的瓶頸落在網卡上。


簡單安裝：

1.分別把memcached和libevent下載回來，放到 /tmp 目錄下：

# cd /tmp

# wget http://www.danga.com/memcached/dist/memcached-1.2.0.tar.gz

# wget http://www.monkey.org/~provos/libevent-1.2.tar.gz


2.先安裝libevent：

# tar zxvf libevent-1.2.tar.gz

# cd libevent-1.2

# ./configure -prefix=/usr

# make （若是遇到提示gcc 沒有安裝則先安裝gcc)

# make install

3.測試libevent是否安裝成功：

# ls -al /usr/lib | grep libevent

lrwxrwxrwx 1 root root 21 11?? 12 17:38 libevent-1.2.so.1 -> libevent-1.2.so.1.0.3

-rwxr-xr-x 1 root root 263546 11?? 12 17:38 libevent-1.2.so.1.0.3

-rw-r-r- 1 root root 454156 11?? 12 17:38 libevent.a

-rwxr-xr-x 1 root root 811 11?? 12 17:38 libevent.la

lrwxrwxrwx 1 root root 21 11?? 12 17:38 libevent.so -> libevent-1.2.so.1.0.3

還不錯，都安裝上了。

4.安裝memcached，同時須要安裝中指定libevent的安裝位置：

# cd /tmp

# tar zxvf memcached-1.2.0.tar.gz

# cd memcached-1.2.0

# ./configure -with-libevent=/usr

# make

# make install

若是中間出現報錯，請仔細檢查錯誤信息，按照錯誤信息來配置或者增長相應的庫或者路徑。

安裝完成後會把memcached放到 /usr/local/bin/memcached ，

5.測試是否成功安裝memcached：

# ls -al /usr/local/bin/mem*

-rwxr-xr-x 1 root root 137986 11?? 12 17:39 /usr/local/bin/memcached

-rwxr-xr-x 1 root root 140179 11?? 12 17:39 /usr/local/bin/memcached-debug

啓動memcache服務

 

啓動Memcached服務：


1.啓動Memcache的服務器端：

# /usr/local/bin/memcached -d -m 8096 -u root -l 192.168.77.105 -p 12000 -c 256 -P /tmp/memcached.pid

-d選項是啓動一個守護進程，

-m是分配給Memcache使用的內存數量，單位是MB，我這裏是8096MB，

-u是運行Memcache的用戶，我這裏是root，

-l是監聽的服務器IP地址，若是有多個地址的話，我這裏指定了服務器的IP地址192.168.77.105，

-p是設置Memcache監聽的端口，我這裏設置了12000，最好是1024以上的端口，

-c選項是最大運行的併發鏈接數，默認是1024，我這裏設置了256，按照你服務器的負載量來設定，

-P是設置保存Memcache的pid文件，我這裏是保存在 /tmp/memcached.pid，


2.若是要結束Memcache進程，執行：

# cat /tmp/memcached.pid 或者 ps -aux | grep memcache   （找到對應的進程id號）

# kill 進程id號

也能夠啓動多個守護進程，不過端口不能重複。

 memcache 的鏈接

telnet  ip   port 

注意鏈接以前須要再memcache服務端把memcache的防火牆規則加上

-A RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 3306 -j ACCEPT 

從新加載防火牆規則

service iptables restart

OK ,如今應該就能夠連上memcache了

在客戶端輸入stats 查看memcache的狀態信息



pid              memcache服務器的進程ID

uptime      服務器已經運行的秒數

time           服務器當前的unix時間戳

version     memcache版本

pointer_size         當前操做系統的指針大小（32位系統通常是32bit）

rusage_user          進程的累計用戶時間

rusage_system    進程的累計系統時間

curr_items            服務器當前存儲的items數量

total_items           從服務器啓動之後存儲的items總數量

bytes                       當前服務器存儲items佔用的字節數

curr_connections        當前打開着的鏈接數

total_connections        從服務器啓動之後曾經打開過的鏈接數

connection_structures          服務器分配的鏈接構造數

cmd_get get命令          （獲取）總請求次數

cmd_set set命令          （保存）總請求次數

get_hits          總命中次數

get_misses        總未命中次數

evictions     爲獲取空閒內存而刪除的items數（分配給memcache的空間用滿後須要刪除舊的items來獲得空間分配給新的items）

bytes_read    讀取字節數（請求字節數）

bytes_written     總髮送字節數（結果字節數）

limit_maxbytes     分配給memcache的內存大小（字節）

threads         當前線程數

redis

 Redis是 在memcache以後編寫的，你們常常把這二者作比較，若是說它是個key-value store 的話可是它具備豐富的數據類型，我想暫時把它叫作緩存數據流中心，就像如今物流中心那樣，order、package、store、 classification、distribute、end。如今還很流行的LAMP PHP架構 不知道和 redis+MySQL 或者 redis + MongoDB的性能比較（聽羣裏的人說mongodb分片不穩定）。

先說說reidis的特性


1. 支持持久化

     redis的本地持久化支持兩種方式：RDB和AOF。RDB 在redis.conf配置文件裏配置持久化觸發器，AOF指的是redis沒增長一條記錄都會保存到持久化文件中（保存的是這條記錄的生成命令），若是 不是用redis作DB用的話還會不要開AOF ，數據太龐大了，重啓恢復的時候是一個巨大的工程！


2.豐富的數據類型

    redis 支持 String 、Lists、sets、sorted sets、hashes 多種數據類型,新浪微博會使用redis作nosql主要也是它具備這些類型，時間排序、職能排序、個人微博、發給個人這些功能List 和 sorted set

   的強大操做功能息息相關


3.高性能

   這點跟memcache很想象，內存操做的級別是毫秒級的比硬盤操做秒級操做天然高效很多，較少了磁頭尋道、數據讀取、頁面交換這些高開銷的操做！這也是NOSQL冒出來的緣由吧，應該是高性能

  是基於RDBMS的衍生產品，雖然RDBMS也具備緩存結構，可是始終在app層面不是咱們想要的那麼操控的。


4.replication

    redis提供主從複製方案，跟mysql同樣增量複製並且複製的實現都很類似，這個複製跟AOF有點相似複製的是新增記錄命令，主庫新增記錄將新增腳本 發送給從庫，從庫根據腳本生成記錄，這個過程很是快，就看網絡了，通常主從都是在同一個局域網，因此能夠說redis的主從近似及時同步，同事它還支持一 主多從，動態添加從庫，從庫數量沒有限制。 主從庫搭建，我以爲仍是採用網狀模式，若是使用鏈式（master-slave-slave-slave-slave·····）若是第一個slave出 現宕機重啓，首先從master 接收 數據恢復腳本，這個是阻塞的，若是主庫數據幾TB的狀況恢復過程得花上一段時間，在這個過程當中其餘的slave就沒法和主庫同步了。


5.更新快

   這點好像從我接觸到redis到目前爲止 已經發了大版本就4個，小版本沒算過。redis做者是個很是積極的人，不管是郵件提問仍是論壇發帖，他都能及時耐心的爲你解答，維護度很高。有人維護的 話，讓咱們用的也省心和放心。目前做者對redis 的主導開發方向是redis的集羣方向。

redis的安裝


redis的安裝其實仍是挺簡單的，總的來講就三步：下載tar包，解壓tar包，安裝。

不過最近我在2.6.7後用centos 5.5 32bit 時碰到一個安裝問題，下面我就用圖片分享下安裝過程碰到的問題，在redis 文件夾內執行make時有個以下的錯 undefined reference to '__sync_add_and_fetch_4'


上網找了了好多最後在  https://github.com/antirez/redis/issues/736 找到解決方案，write CFLAGS= -march=i686 on src/Makefile head!


記得要把剛安裝失敗的文件刪除，從新解壓新的安裝文件，修改Makefile文件，再make安裝。就不會發現原來那個錯誤了

關於redis的一些屬性註釋和基本類型操做在上一篇redis 的開胃菜有詳細的說明，這裏就再也不重複累贅了（實質是想偷懶 ，哈哈！）


最後，把memcache和redis放在一塊兒不得不會讓人想到二者的比較，誰快誰好用啊，羣裏面已經爲這個事打架好久了，我就把我看到的在這裏跟你們分享下。

在別人發了一個memcache性能比redis好不少後，redis 做者 antirez 發表了一篇博文，主要是說到如何給redis 和 memcache 作壓力測試，文中講到有我的說許多開源軟件都應該丟進廁所，由於他們的壓力測試腳本太2了，做者對這個說明了一番。redis  vs  memcache is  definitely an apple to apple comparison。 呵呵，很明確吧，二者的比較是否是有點雞蛋挑骨頭的效果，做者在相同的運行環境作了三次測試取多好的值，獲得的結果以下圖:


須要申明的是這次測試在單核心處理的過程的數據，memcache是支持多核心多線程操做的（默認沒開）因此在默認狀況下上圖具備參考意義，若然則 memcache快於redis。那爲何redis不支持多線程多核心處理呢？做者也發表了一下本身的見解，首先是多線程不變於bug的修復，實際上是不 易軟件的擴展，還有數據一致性問題由於redis全部的操做都是原子操做，做者用到一個詞nightmare 噩夢，呵呵！  固然不支持多線程操做，確定也有他的弊端的好比性能想必必然差，做者從2.2版本後專一redis cluster的方向開發來緩解其性能上的弊端，說白了就是縱向不行，橫向提升。

應用場景：

 

ehcache直接在jvm虛擬機中緩存，速度快，效率高；可是緩存共享麻煩，集羣分佈式應用不方便。
 redis是經過socket訪問到緩存服務，效率比ecache低，比數據庫要快不少，處理集羣和分佈式緩存方便，有成熟的方案。
 
 若是是單個應用或者對緩存訪問要求很高的應用，用ehcache。
 若是是大型系統，存在緩存共享、分佈式部署、緩存內容很大的，建議用redis。
 
 補充下：ehcache也有緩存共享方案，不過是經過RMI或者Jgroup多播方式進行廣播緩存通知更新，緩存共享複雜，維護不方便；簡單的共享能夠，可是涉及到緩存恢復，大數據緩存，則不合適

redis和memcached相比的獨特之處：
一、redis能夠用來作存儲(storage),而memcached是用來作緩存(cache)
這個特色主要由於其有持久化功能

二、redis中存儲的數據有多種結構，而memcached存儲的數據只有一種類型「字符串」





第二種理解:

第一：二者之間的介紹

 

Redis：屬於獨立的運行程序，須要單獨安裝後，使用JAVA中的Jedis來操縱。由於它是獨立，因此若是你寫個單元測試程序，放一些數據在Redis中，而後又寫一個程序去拿數據，那麼是能夠拿到這個數據的。，
 

 

ehcache：與Redis明顯不一樣，它與java程序是綁在一塊兒的，java程序活着，它就活着。譬如，寫一個獨立程序放數據，再寫一個獨立程序拿數據，那麼是拿不到數據的。只能在獨立程序中才能拿到數據。
 

 


 
 

 

第二：使用及各類配置：
 

 

二者均可以集羣：
 

 

1.Redis能夠作主歷來集羣，例如，在A電腦上裝個Redis，做爲主庫；在其餘電腦上裝Redis，做爲從庫；這樣主庫擁有讀和寫的功能，而從庫只擁有讀的功能。每次主庫的數據都會同步到從庫中。
 

 

1.默認方式啓動
 

 

 

 
 
    Linux下使用Redis  
    安裝：從官網上下載tar.gz格式的包，而後使用tar zxvf redis-2.8.24.tar.gz命令解壓，而後進入Redis文件夾目錄下的src目錄，使用make編譯一下  
      
    1.開啓：進入/usr/local/redis-3.2.1/src  
    而後./redis-server  

 

 

 
 


 
 

 

2.若是咱們想修改端口，設置密碼：那麼得修改配置文件的redis.conf
 

 

port 6379                                         //端口修改
 

 

requirepass redis123                  //設置密碼  redis123爲密碼
 

 


 
 

 

配置主從：主庫的配置文件不用修改，從庫的配置文件須要修改，由於從庫須要綁定主庫，以即可以獲取主庫的數據
 

 

slaveof 192.168.1.100 6379                              //主庫的IP地址和端口號
 masterauth redis123                                      //主庫設定的密碼
 

 

3.要讓配置文件的屬性生效，那麼啓動的redis的時候，要將配置文件加上去
 

 

進入/usr/local/redis-3.2.1/src
 

 

而後 ./redis-server  redis.conf
 

 

那麼將成功的啓動redis，若是沒有加入配置的話，按照普通方式啓動的話，端口仍然仍是6379.
 

 


 
 

 

4.客戶端鏈接遠程的Redis
 第一步：在遠程端處設置密碼：config set requirepass 123       //123爲密碼
 第二步：能夠在客戶端登陸  redis-cli.exe -h 114.215.125.42 -p 6379 
 第三步：認證：auth 123                                       //123爲密碼
 本地端設置密碼後，要使用密碼登陸；若是Redis重啓的話，密碼須要從新設置
 

 

5.主從配置後，爲保證主庫寫的能力，通常不在主庫作持久化，而是在從庫作持久化：
 

 

主庫配置：
 

 

將save註釋，不使用rdb
 

 

# save 900 1
 # save 300 10
 # save 60 10000
 
 

 


 
 

 

appendonly no        不使用aof
 
 

 


 
 

 

從庫配置：
 
 

 

save 900 1
 save 300 10
 save 60 10000
 
 

 

appendonly yes
 
 

 


 
 

 

這樣作的優缺點：
 

 

優勢：保證了主庫寫的能力。
 

 

缺點：主庫掛掉後，重啓主庫，而後進行第一次寫的動做後，主庫會先生成rdb文件，而後傳輸給從庫，從而覆蓋掉從庫原先的rdb文件，形成數據丟失。可是第二次寫的時候，主庫會以快照方式直接傳數據給從庫，不會從新生成rdb文件。
 

 

解決方案：先複製從庫中的數據到主庫後，再啓動主庫。
 

 

使用：
 

 

引入jedis包
 

 
 
    <dependency>  
        <groupId>redis.clients</groupId>  
        <artifactId>jedis</artifactId>  
        <version>2.7.3</version>  
    </dependency>  
 

 

 
 

 

 
 

簡單的寫個類玩玩吧
 

 

 
 
 
  
 
   
 
    
    public class RedisMain {  
          
          
        public static void main(String [] str)  
        {  
              
             Jedis jedis = new Jedis("114.215.125.42",6379);  
             jedis.auth("123");     //密碼認證  
              System.out.println("Connection to server sucessfully");  
              //查看服務是否運行  
              jedis.set("user","namess");  
             // System.out.println("Server is running: "+jedis.ping());  
              System.out.println(jedis.get("user").toString());  
              jedis.set("user","name");  
              System.out.println(jedis.get("user"));  
                
      
        }  
      
    }  
 
   
 
   
 
 
  
 
 
 

 

 Redis完畢
 


 
 

 

下面說說Ehcache:
 

 

Ehcache的使用：
 

 

1.首先引入包
 

 

 
 
 
  
 
   
 
    
    <dependency>  
               <groupId>net.sf.ehcache</groupId>  
               <artifactId>ehcache-core</artifactId>  
               <version>2.6.6</version>  
           </dependency>  
       
           <dependency>  
               <groupId>org.slf4j</groupId>  
               <artifactId>slf4j-log4j12</artifactId>  
               <version>1.6.6</version>  
           </dependency>  
 
   
 
   
 
 
  
 
 
 

 

 

2.建立一個ehcache.xml文件，裏面配置cache的信息，這個配置是包含了集羣的配置：與192.168.93.129：40001的 機器集羣了：Ip爲192.168.93.129機子的配置要將rmiUrls對應的數據改成這個配置文件的機子的IP地址，和對應的緩存名字
 

 

 
 
 
  
 
   
 
    
    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
       xsi:noNamespaceSchemaLocation="ehcache.xsd">  
        <cacheManagerPeerProviderFactory   
       class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"  
    properties="peerDiscovery=manual,rmiUrls=//192.168.93.129:40001/demoCache"/>           <!--另外一臺機子的ip緩存信息-->  
    <cacheManagerPeerListenerFactory class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"  
    properties="hostName=localhost,port=40001,socketTimeoutMillis=2000" />                  <!--hostName表明本機子的ip-->     
      <diskStore path="java.io.tmpdir"/>  
      <defaultCache  
        maxElementsInMemory="10000"  
        maxElementsOnDisk="0"  
        eternal="true"  
        overflowToDisk="true"  
        diskPersistent="false"  
        timeToIdleSeconds="0"  
        timeToLiveSeconds="0"  
        diskSpoolBufferSizeMB="50"  
        diskExpiryThreadIntervalSeconds="120"  
        memoryStoreEvictionPolicy="LFU"  
        >  
         <cacheEventListenerFactory    
                    class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>                
        </defaultCache>  
      <cache name="demoCache"  
        maxElementsInMemory="100"  
        maxElementsOnDisk="0"  
        eternal="false"  
        overflowToDisk="false"  
        diskPersistent="false"  
        timeToIdleSeconds="119"  
        timeToLiveSeconds="119"  
        diskSpoolBufferSizeMB="50"  
        diskExpiryThreadIntervalSeconds="120"  
        memoryStoreEvictionPolicy="FIFO"  
        >  
        <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>          <!--監聽這個cache-->  
        </cache>  
    </ehcache>  
 
   
 
   
 
 
  
 
 
 

 

 
 

配置完後寫代碼：
 

 

放數據：
 

 

 
 
 
  
 
   
 
    
    @RequestMapping("/testehcache.do")  
        public void testehcache(HttpServletResponse response) throws IOException  
        {  
            URL url = getClass().getResource("ehcache.xml");   
             CacheManager singletonmanager = CacheManager.create(url);  
            Cache cache = singletonmanager.getCache("demoCache");  
            //使用緩存  
            Element element = new Element("key1", "value1");  
            cache.put(element);  
            cache.put(new Element("key2", "value2"));  
             
            response.getWriter().println("我存放了數據");  
        }  
 
   
 
   
 
 
  
 
 
 

 

 


 
 

 

拿數據：
 

 
 
@RequestMapping("/getcache.do")  
    public void getcache(HttpServletResponse response) throws IOException  
    {  
        CacheManager singletonmanager = CacheManager.create();   
        Cache cache = singletonmanager.getCache("demoCache");  
        String one=cache.get("key1").getObjectValue().toString();  
        String two=cache.get("key2").getObjectValue().toString();  
        response.getWriter().println(one+two);  
    } 
 

 

配置集羣后，A機器放數據，在B機器上能拿到數據，B機器放數據，A機器也能夠拿到數據


        

            

        	





    

		

            
相關文章

            

                

                

                    

                

            


            
相關標籤/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公眾號
    

    

           歡迎關注本站公眾號,獲取更多信息

        
    




    

    




	


	







    

        聯繫我們
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程