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,但是最后放弃了,放弃原因包括:.