java使用memcached缓存

标签： java memcached 缓存 | 发表时间：2014-06-22 22:08 | 作者：shibin_1109
出处：http://www.iteye.com
服务器端安装,部署,启动: 

1.下载libevent,安装libevent
cd /tmp
wget https://github.com/downloads/libevent/libevent/libevent-2.0.21-stable.tar.gz
tar -zxvf libevent-2.0.21-stable.tar.gz
cd libevent-2.0.21-stable
./configure --prefix=/usr/local/libevent
make && make install

2.下载memcached,安装memcached
wget http://memcached.org/latest 
tar -zxvf memcached-1.4.17.tar.gz
cd memcached-1.4.17
./configure --prefix=/usr/local/memcache --with-libevent=/usr/local/libevent/
make &&  make install
cd /usr/local/memcached/bin
./memcached -d -m 64 -u root -p 55001 -c 2048 

查看memcached的状态
ps -ax|grep memcache

链接到memcache
telnet cache.expai.com 55001
查看状态
stats

查看缓存占了多少空间
cat /proc/id/statm
启动参数
./memcached -d -m 1024 -u root -p 55001 -c 2048

memcached启动参数
 
-p 指定端口号（默认11211）  
-U <num> UDP监听端口 (默认: 11211, 0 时关闭) 
-s <file>     用于监听的UNIX套接字路径（禁用网络支持）
-a <mask>     UNIX套接字访问掩码，八进制数字（默认：0700）
-m 指定最大使用内存大小（默认64MB）   
-t 线程数（默认4）
 
-l <ip_addr> 绑定地址 (默认:所有都允许,无论内外网或者本机更换IP，有安全隐患，若设置为127.0.0.1就只能本机访问) 
-d start 启动memcached服务   
-d restart 重起memcached服务   
-d stop|shutdown 关闭正在运行的memcached服务   
-u <username> 绑定使用指定用于运行进程 <username>  （只有root用户可以使用这个参数）
-P <file> 将PID写入文件<file>，这样可以使得后边进行快速进程终止, 需要与 -d 一起使用
-m 最大内存使用，单位MB。默认64MB     www.2cto.com  
 
-M 内存耗尽时返回错误，而不是删除项   
-c 最大同时连接数，默认是1024 
-f 块大小增长因子，默认是1.25 
-n <bytes>最小分配空间，key+value+flags默认是48
-k锁定所有内存页。注意你可以锁定的内存上限。
 
试图分配更多内存会失败的，所以留意启动守护进程时所用的用户可分配的内存上限。
（不是前面的 -u <username> 参数；在sh下，使用命令"ulimit -S -l NUM_KB"来设置。）
-v 提示信息（在事件循环中打印错误/警告信息。）
-vv 详细信息（还打印客户端命令/响应）
-vvv 超详细信息（还打印内部状态的变化）
-h 打印这个帮助信息并退出。
-i  打印memcached和libevent的许可。
-L 尝试使用大内存页（如果可用的话）。提高内存页尺寸可以减少"页表缓冲（TLB）"丢失次数，提高运行效率。  www.2cto.com  
 
              为了从操作系统获得大内存页，memcached会把全部数据项分配到一个大区块。
-D <char>     使用 <char> 作为前缀和ID的分隔符。
              这个用于按前缀获得状态报告。默认是":"（冒号）。
              如果指定了这个参数，则状态收集会自动开启；如果没指定，则需要用命令"stats detail on"来开启。
-t <num>      使用的线程数（默认：4）
-R 每个连接可处理的最大请求数。
-C 禁用CAS。
-b 设置后台日志队列的长度（默认：1024）
-B 绑定协议 - 可能值：ascii,binary,auto（默认）
-I 重写每个数据页尺寸。调整数据项最大尺寸。

默认memcache会监听11221端口，如果想清空服务器上memecache的缓存，大家一般使用的是：
telnet localhost 11211
flush_all

同样也可以使用：
echo "flush_all" | nc localhost 11211

使用flush_all 后并不是删除memcache上的key，而是置为过期

java客户端使用: 
package com.expai.utils;

import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
import com.expai.mapper.advertise.AdverTiseMapper;
import com.expai.mapper.user.UserMapper;
import com.expai.model.hotimage.HotImage;
import com.expai.model.ir.Advertise;
import com.expai.model.user.User;
import com.mongodb.BasicDBList;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;

/**
 * 
 * Description:
 * DateTime 2014年1月21日 下午4:19:28
 * @author louyj
 * @company expai
 * @version 1.0
 *
 */
public class MemCachedUtil {
	
	private static final Logger logger = Logger.getLogger(MemCachedUtil.class);
	
	 //构建缓存客户端
	 private static MemCachedClient  cachedClient;
	// 单例模式实现客户端管理类  
     private static MemCachedUtil INSTANCE = new MemCachedUtil();
     private MemCachedUtil() {  
         cachedClient = new MemCachedClient();  
         cachedClient.setPrimitiveAsString(true);
         // cachedClient.setSanitizeKeys(arg0)
         //获取连接池实例  
         SockIOPool pool = SockIOPool.getInstance();  
         // http://:/
         //设置缓存服务器地址，可以设置多个实现分布式缓存  服务器列表和其权重
         // pool.setServers(new String[]{"115.29.251.56:55001,115.29.251.56:55002,115.29.251.56:55003"});  
         //pool.setServers(new String[]{"10.162.57.11:55001"});  
         
        pool.setServers(new String[]{"s4.expai.com:55001"});  
        //  pool.setServers(new String[]{"192.168.81.137:55001"});  
         
        Integer[] weights = {3};
        //,"10.162.57.11:55001","10.162.57.11:55002","10.162.57.11:55003"
        pool.setWeights( weights );
         //pool.setServers(new String[]{"192.168.4.39:55001"});  
         //设置初始连接5  
         pool.setInitConn(5);  
         //设置最小连接5  
         pool.setMinConn(5);  
         //设置最大连接2048  
         pool.setMaxConn(2048);  
         //设置每个连接最大空闲时间3个小时  
         pool.setMaxIdle(1000 * 60 * 60 * 3);  
   
         pool.setMaintSleep(30);  
   
         pool.setNagle(false);  
         pool.setSocketTO(3000);  
         pool.setSocketConnectTO(0);  
         pool.initialize(); 
     } 
     
     /** 
      * 获取缓存管理器唯一实例 
      * @return 
      */  
     public static MemCachedUtil getInstance() {  
         return INSTANCE;  
     } 
     
     public void add(String key, Object value) {  
         cachedClient.add(key, value);  
     }  
   
       //int设置缓存失效时间,相对时间毫秒
     public void add(String key, Object value, int milliseconds) {  
         cachedClient.add(key, value, milliseconds);  
     }  
     public void set(String key, Object value) {  
    	 cachedClient.set(key, value);  
     }  
     
     //int设置缓存失效时间,相对时间毫秒
     public void set(String key, Object value, int milliseconds) {  
    	 cachedClient.set(key, value, milliseconds);  
     }  
   
       
     public void remove(String key) {  
         cachedClient.delete(key);  
         cachedClient.flushAll();
     }  
   
       
     @SuppressWarnings("deprecation")
	public void remove(String key, int milliseconds) {  
         cachedClient.delete(key, milliseconds, new Date());  
         cachedClient.flushAll();
     }  
   
       
     public void update(String key, Object value, int milliseconds) {  
         cachedClient.replace(key, value, milliseconds);  
     }  
   
       
     public void update(String key, Object value) {  
         cachedClient.replace(key, value);  
     }  
       
       
       
     public Object get(String key) {  
         return cachedClient.get(key);  
     }  
     public void getAll(){
      logger.debug(cachedClient);
     }
     
     /**
      * 初始化识别信息缓存
      */
     public static void initMemcachedIdenData(){
     	SqlSession session = null;
 		session = SessionFactory.getSession();
 	    AdverTiseMapper adMap = null;
 	    adMap = session.getMapper(AdverTiseMapper.class);
 	    List<Advertise> advertiseList = adMap.getAdvertises();
 	    if(advertiseList!=null&&advertiseList.size()>0){
 	    	for(Advertise advertise:advertiseList){
 	    		if(null!=advertise.getUrl()&&!advertise.getUrl().equals("")){
 	    			logger.debug("Advertise"+advertise.getId()+"的识别结果为:"+advertise.getUrl());
 	    			MemCachedUtil.getInstance().set("adveriden"+advertise.getId(), advertise.getUrl());
 	    		}else{
 	    			logger.debug("Advertise"+advertise.getId()+"的识别结果为:"+advertise.getUrl());
 	    			MemCachedUtil.getInstance().set("adveriden"+advertise.getId(), "url is null");
 	    		}
 	    		if(null!=advertise.getKeyword()&&!advertise.getKeyword().equals("")){
 	    			logger.debug("Advertise"+advertise.getId()+"的关键字为:"+advertise.getKeyword());
 	    			MemCachedUtil.getInstance().set("adverkey"+advertise.getId(), advertise.getKeyword());
 	    		}else{
 	    			logger.debug("Advertise"+advertise.getId()+"的关键字为:"+advertise.getKeyword());
 	    			MemCachedUtil.getInstance().set("adverkey"+advertise.getId(), "key is null");
 	    		}
 	    		if(null!=advertise.getImage()&&!advertise.getImage().equals("")){
 	    			logger.debug("Advertise"+advertise.getId()+"的图片地址为:"+advertise.getImage());
 	    			MemCachedUtil.getInstance().set("adverimage"+advertise.getId(), advertise.getImage());
 	    		}else{
 	    			logger.debug("Advertise"+advertise.getId()+"的图片地址为:"+advertise.getImage());
 	    			MemCachedUtil.getInstance().set("adverimage"+advertise.getId(), "image is null");
 	    		}
 	    	}
 	    }
 	    //初始化tb_newspaper里的识别信息
 	   List<Advertise> newspaperList = adMap.getNewspapers();
	    if(newspaperList!=null&&newspaperList.size()>0){
	    	for(Advertise advertise:newspaperList){
	    		if(null!=advertise.getUrl()&&!advertise.getUrl().equals("")){
	    			logger.debug("Advertise"+advertise.getId()+"的识别结果为:"+advertise.getUrl());
	    			MemCachedUtil.getInstance().set("newsiden"+advertise.getId(), advertise.getUrl());
	    		}else{
	    			logger.debug("Advertise"+advertise.getId()+"的识别结果为:"+advertise.getUrl());
	    			MemCachedUtil.getInstance().set("newsiden"+advertise.getId(), "url is null");
	    		}
	    		if(null!=advertise.getKeyword()&&!advertise.getKeyword().equals("")){
 	    			logger.debug("Advertise"+advertise.getId()+"的关键字为:"+advertise.getKeyword());
 	    			MemCachedUtil.getInstance().set("newskey"+advertise.getId(), advertise.getKeyword());
 	    		}else{
 	    			logger.debug("Advertise"+advertise.getId()+"的关键字为:"+advertise.getKeyword());
 	    			MemCachedUtil.getInstance().set("newskey"+advertise.getId(), "key is null");
 	    		}
	    		if(null!=advertise.getImage()&&!advertise.getImage().equals("")){
 	    			logger.debug("Advertise"+advertise.getId()+"的图片地址为:"+advertise.getImage());
 	    			MemCachedUtil.getInstance().set("newsimage"+advertise.getId(), advertise.getImage());
 	    		}else{
 	    			logger.debug("Advertise"+advertise.getId()+"的图片地址为:"+advertise.getImage());
 	    			MemCachedUtil.getInstance().set("newsimage"+advertise.getId(), "image is null");
 	    		}
	    	}
	    }
     }
     
    
     */
     /**
      * 初始化广告信息tb_embedAdvertise
      * @throws UnsupportedEncodingException 
      */
     public static void initMemcachedEmbedDate() throws UnsupportedEncodingException{
    	 long st = System.currentTimeMillis();
     	DB db = MongdbUtil.startMongoDBConn();
     	DBCollection inputCollection =db.getCollection("tb_embedAdvertise"); 
     	DBObject ref = new BasicDBObject();
     	DBCursor cursor = inputCollection.find(ref);
 		List<DBObject> list = cursor.toArray();
 		long et = System.currentTimeMillis();
 		long diff = et-st;
 		logger.info("query all advertise expand time : " + diff);
 		MemCachedUtil instance = MemCachedUtil.getInstance();
  		if(list!=null&&list.size()>0){
  			logger.info("all advertise total number : " + list.size());
  			for(int i =0, n = list.size(); i < n; i++){
  				DBObject object = list.get(i);
  				Object url = object.get("url");
  				Object loc = object.get("loc");
  				String str = new String(object.toString().getBytes("UTF-8"));
 				if(null!=url && !url.toString().equals("")){
 					logger.debug("The is cache Advertise url======"+"em" + new MD5().getMD5ofStr(url.toString()));
 					instance.add("em" + new MD5().getMD5ofStr(url.toString()), str);
 				}
 				
 				if(null != loc && !loc.toString().equals("")){
 					logger.debug("The is cache Advertise loc======"+"em" + new MD5().getMD5ofStr(loc.toString()));
 					instance.add("em" + new MD5().getMD5ofStr(loc.toString()), str);
 				}
  				Utils.writeText(str, "/data/memcached.txt");
  			}
  			logger.info("memcached add complete");
  		}
  		MongdbUtil.stopMondoDBConn();
     }
     
     
   
     public static void initMemcachedImageAll(){
    	 	DB db = MongdbUtil.startMongoDBConn();
	    	DBCollection inputCollection =db.getCollection("tb_hotimage_failure"); 
	    	DBCursor cursor = inputCollection.find();
	    	List<DBObject> list = cursor.toArray();
	    	for(int i =0, n = list.size(); i < n; i++){
				DBObject object = list.get(i);
				Object shortlocation = object.get("shortlocation");
				if(null!=shortlocation && !shortlocation.toString().equals("")){
					logger.debug("add tb_hotimage_failure======================"+shortlocation);
					MemCachedUtil.getInstance().set(new MD5().getMD5ofStr(String.valueOf(shortlocation)),"failure");
				}
			}
	    	
	    	DBCollection inputCollection1 =db.getCollection("tb_hotimage"); 
	    		BasicDBObject obj = new BasicDBObject();
	    		BasicDBObject query = new BasicDBObject();
	    		BasicDBList values = new BasicDBList();  
	    		values.add("sdchina.com");
	    		values.add("gywb.cn");
	    		values.add("nen.com");
	    		values.add("yunying");
	    		values.add("shangdu.com");
	    		values.add("voc.com");
	    		values.add("0554news.com");
	    		query.append("$in", values);
	    		obj.append("categoryId", query);
	    	DBCursor cursor1 = inputCollection1.find(obj);
	    	List<DBObject> list1 = cursor1.toArray();
	    	for(int i =0, n = list1.size(); i < n; i++){
				DBObject object1 = list1.get(i);
				Object shortlocation = object1.get("shortlocation");
				if(null!=shortlocation && !shortlocation.toString().equals("")){
					logger.debug("add tb_hotimage======================"+shortlocation);
					MemCachedUtil.getInstance().set(new MD5().getMD5ofStr(String.valueOf(shortlocation)),"success");
				}
			}
	    	MongdbUtil.stopMondoDBConn();
     }
	public static void main(String[] args) {
		initMemcachedImageAll();
	}
}


memcached jar包: 
        <dependency>
  	   <groupId>memcached</groupId>
  	   <artifactId>java_memcached-release</artifactId>
  	   <version>2.6.6</version>
        </dependency>


已有 0 人发表留言，猛击->> 这里<<-参与讨论


ITeye推荐



相关 [java memcached 缓存] 推荐：

java使用memcached缓存

- - Linux - 操作系统 - ITeye博客
服务器端安装,部署,启动:. 用于监听的UNIX套接字路径（禁用网络支持） -a . UNIX套接字访问掩码，八进制数字（默认：0700） -m 指定最大使用内存大小（默认64MB）. -t 线程数（默认4） -l 绑定地址 (默认:所有都允许,无论内外网或者本机更换IP，有安全隐患，若设置为127.0.0.1就只能本机访问) -d start 启动memcached服务.

Java使用memcached

- - 互联网 - ITeye博客
首先到 http://danga.com/memcached下载memcached的windows版本和java客户端jar包，目前最新版本是memcached-1.2.1-win32.zip和java_memcached-release_1.6.zip，分别解压后即可. 然后是安装运行memcached服务器，我们将memcached-1.2.1-win32.zip解压后，进入其目录，然后运行如下命令：c:>;memcached.exe -d install
c:>memcached.exe -l 127.0.0.1 -m 32 -d start.

分布式缓存-Memcached

- - 人月神话的BLOG
分布式缓存出于如下考虑，首先是缓存本身的水平线性扩展问题，其次是缓存大并发下的本身的性能问题，再次避免缓存的单点故障问题(多副本和副本一致性). 分布式缓存的核心技术包括首先是内存本身的管理问题，包括了内存的分配，管理和回收机制. 其次是分布式管理和分布式算法，其次是缓存键值管理和路由. 原文： http://wenku.baidu.com/view/8686d46c7e21af45b307a8c3.html.

Reddit如何使用Memcached来存储3TB的缓存数据

- - IT瘾-tuicool
Reddit是著名的社交新闻网站，光是在2012年，它的独立访客就达到了4000万，页面浏览量达到了370亿次. 几年过去了，网站用户有增无减，而随着用户的增多，网站的响应速度却一直在改进. 这要得益于Reddit使用了大量的缓存. 而随着网站规模不断增长，缓存数量也随着增加，那么Reddit是如何做到在增大缓存规模的同时又能保证它们的响应速度的.

应对Memcached缓存失效，导致高并发查询DB的几种思路

- - ImportNew
最近看到nginx的合并回源，这个和下面的思路有点像. 不过nginx的思路还是在控制缓存失效时的并发请求，而不是当缓存快要失效时，及时地更新缓存. nginx合并回源，参考：http://blog.csdn.net/brainkick/article/details/8570698. 当Memcached缓存失效时，容易出现高并发的查询DB，导致DB压力骤然上升.

读取memcached和redis中的数据，分析缓存数据大小

- - BlogJava-首页技术区
    最近项目快要见人了，所以很多性能分析的需求又提出来了. 之前已经做过几次类似的事情，这次记录下来把.     Memcached不能一次性读取所有的key，不能一次性读取缓存数据. 以前项目里面踩过这个坑，stats cachedump $slabId $limit只会dump出2M的key，如果所有的key超多2M那么dump出哪些key就要看命了.

memcached+magent实现memcached集群

- - 编程语言 - ITeye博客
首先说明下memcached存在如下问题. 　　本身没有内置分布式功能，无法实现使用多台Memcache服务器来存储不同的数据，最大程度的使用相同的资源；无法同步数据，容易造成单点故障. （memagent代理实现集群）.       在 Memcached中可以保存的item数据量是没有限制的，只要内存足够.

写Java也得了解CPU缓存

- - 忘我的追寻
CPU，一般认为写C/C++的才需要了解，写高级语言的(Java/C#/pathon…)并不需要了解那么底层的东西. 我一开始也是这么想的，但直到碰到LMAX的 Disruptor，以及 马丁的博文，才发现写Java的，更加不能忽视CPU. 经过一段时间的阅读，希望总结一下自己的阅读后的感悟. 本文主要谈谈CPU缓存对Java编程的影响，不涉及具体CPU缓存的机制和实现.

MemCached详解

- - CSDN博客推荐文章
首先，我们来了解一下MemCached与MemCache之间的区别：. Memcache是一个自由和开放源代码、高性能、分配的内存对象缓存系统. 用于加速动态web应用程序，减轻数据库负载. 它可以应对任意多个连接，使用非阻塞的网络IO. 由于它的工作机制是在内存中开辟一块空间，然后建立一个HashTable，Memcached自管理这 些HashTable.

Memcached调优

- - 四火的唠叨
文章系本人原创，转载请保持完整性并注明出自 《四火的唠叨》. 项目中有一个对实时响应性比较高的服务，引入了Memcached以减少延迟和减少数据库压力. 但是期间遇到了一些问题，这里记录一些调优细节. 最开始我使用的是 Memcached Java Client，但是最后放弃了，放弃原因包括：.