memcached基本配置与使用

最新推荐文章于 2024-06-19 22:10:37 发布

和代码去流浪

最新推荐文章于 2024-06-19 22:10:37 发布

阅读量1.9k

点赞数

分类专栏：数据库、缓存、nosql 文章标签： memcached 服务器 java

原文链接：https://blog.csdn.net/sup_heaven/article/details/32337711

版权

数据库、缓存、nosql 专栏收录该内容

111 篇文章 5 订阅

订阅专栏

一、概念

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

二、原理

Memcached有两个核心组件组成：服务端（ms）和客户端（mc）。首先mc拿到ms列表，并对key做hash转化，根据hash值确定kv对所存的ms位置。然后在一个memcached的查询中，mc先通过计算key的hash值来确定kv对所处在的ms位置。当ms确定后，客户端就会发送一个查询请求给对应的ms，让它来查找确切的数据。因为ms之间并没有护卫备份，也就不需要互相通信，所以效率较高。

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

四、客户端版本

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

五、服务器端

安装

这里介绍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，从而提供整体的内存使用率。

缓存策略

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

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

六、范例

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工具类：

public class MemcachedUtil {
/**
 * memcached客户端单例
 */
private static MemCachedClient cachedClient &#61; new MemCachedClient();

/**
 * 初始化连接池
 */
static {
	//获取连接池的实例
	SockIOPool pool &#61; SockIOPool.getInstance();
	
	//服务器列表及其权重
	String[] servers &#61; {&#34;127.0.0.1:11211&#34;};
	Integer[] weights &#61; {3};
	
	//设置服务器信息
	pool.setServers(servers);
	pool.setWeights(weights);
	
	//设置初始连接数、最小连接数、最大连接数、最大处理时间
	pool.setInitConn(10);
	pool.setMinConn(10);
	pool.setMaxConn(1000);
	pool.setMaxIdle(1000*60*60);
	
	//设置连接池守护线程的睡眠时间
	pool.setMaintSleep(60);
	
	//设置TCP参数&#xff0c;连接超时
	pool.setNagle(false);
	pool.setSocketTO(60);
	pool.setSocketConnectTO(0);
	
	//初始化并启动连接池
	pool.initialize();
	
	//压缩设置&#xff0c;超过指定大小的都压缩

// cachedClient.setCompressEnable(true);
// cachedClient.setCompressThreshold(1024*1024);
}

private MemcachedUtil(){
}

public static boolean add(String key, Object value) {
	return cachedClient.add(key, value);
}

public static boolean add(String key, Object value, Integer expire) {
	return cachedClient.add(key, value, expire);
}

public static boolean put(String key, Object value) {
	return cachedClient.set(key, value);
}

public static boolean put(String key, Object value, Integer expire) {
	return cachedClient.set(key, value, expire);
}

public static boolean replace(String key, Object value) {
	return cachedClient.replace(key, value);
}

public static boolean replace(String key, Object value, Integer expire) {
	return cachedClient.replace(key, value, expire);
}

public static Object get(String key) {
	return cachedClient.get(key);
}

}3. 创建需要缓存的对象：

public class UserBean implements Serializable {
private static final long serialVersionUID &#61; 9174194101246733501L;

private String username;

private String password;

public UserBean(String username, String password) {
	this.username &#61; username;
	this.password &#61; password;
}

public String getUsername() {
	return username;
}

public void setUsername(String username) {
	this.username &#61; username;
}

public String getPassword() {
	return password;
}

public void setPassword(String password) {
	this.password &#61; password;
}

&#64;Override
public int hashCode() {
	final int prime &#61; 31;
	int result &#61; 1;
	result &#61; prime * result
			&#43; ((password &#61;&#61; null) ? 0 : password.hashCode());
	result &#61; prime * result
			&#43; ((username &#61;&#61; null) ? 0 : username.hashCode());
	return result;
}

&#64;Override
public boolean equals(Object obj) {
	if (this &#61;&#61; obj)
		return true;
	if (obj &#61;&#61; null)
		return false;
	if (getClass() !&#61; obj.getClass())
		return false;
	UserBean other &#61; (UserBean) obj;
	if (password &#61;&#61; null) {
		if (other.password !&#61; null)
			return false;
	} else if (!password.equals(other.password))
		return false;
	if (username &#61;&#61; null) {
		if (other.username !&#61; null)
			return false;
	} else if (!username.equals(other.username))
		return false;
	return true;
}

&#64;Override
public String toString() {
	return &#34;username:&#34; &#43; username &#43; &#34;,password:&#34; &#43; password;
}

}4.创建测试用例：

public class MemcachedUtilTest {
&#64;Test
public void testMemcached() {
	MemcachedUtil.put(&#34;hello&#34;, &#34;world&#34;, 60);
	String hello &#61; (String) MemcachedUtil.get(&#34;hello&#34;);
	Assert.assertEquals(&#34;world&#34;, hello);
	
	for(int i &#61; 0; i &lt; 10000000; &#43;&#43;i) {
		UserBean userBean &#61; new UserBean(&#34;Jason&#34; &#43; i, &#34;123456-&#34; &#43; i);
		MemcachedUtil.put(&#34;user&#34; &#43; i, userBean, 60);
		Object obj &#61; MemcachedUtil.get(&#34;user&#34; &#43; i);
		Assert.assertEquals(userBean, obj);
	}
}

}

5.通过spring注入memcached：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">
&lt;bean id&#61;&#34;memcachedPool&#34; class&#61;&#34;com.danga.MemCached.SockIOPool&#34; 
	factory-method&#61;&#34;getInstance&#34; init-method&#61;&#34;initialize&#34;&gt;
	&lt;constructor-arg&gt;
		&lt;value&gt;neeaMemcachedPool&lt;/value&gt;
	&lt;/constructor-arg&gt;
	&lt;property name&#61;&#34;servers&#34;&gt;
		&lt;list&gt;
			&lt;value&gt;127.0.0.1:11211&lt;/value&gt;
		&lt;/list&gt;
	&lt;/property&gt;
	&lt;property name&#61;&#34;initConn&#34;&gt;
		&lt;value&gt;20&lt;/value&gt;
	&lt;/property&gt;
	&lt;property name&#61;&#34;minConn&#34;&gt;
		&lt;value&gt;10&lt;/value&gt;
	&lt;/property&gt;
	&lt;property name&#61;&#34;maxConn&#34;&gt;
		&lt;value&gt;50&lt;/value&gt;
	&lt;/property&gt;
	&lt;property name&#61;&#34;nagle&#34;&gt;
		&lt;value&gt;false&lt;/value&gt;
	&lt;/property&gt;
	&lt;property name&#61;&#34;socketTO&#34;&gt;
		&lt;value&gt;3000&lt;/value&gt;
	&lt;/property&gt;
&lt;/bean&gt;
&lt;bean id&#61;&#34;memcachedClient&#34; class&#61;&#34;com.danga.MemCached.MemCachedClient&#34;&gt;
	&lt;constructor-arg&gt;
		&lt;value&gt;neeaMemcachedPool&lt;/value&gt;
	&lt;/constructor-arg&gt;
&lt;/bean&gt;

</beans>

6.创建测试用例：

public class MemcachedSpringTest {
private MemCachedClient cachedClient;

&#64;Before
public void init() {
	ApplicationContext context &#61; new ClassPathXmlApplicationContext(&#34;com/luo/config/beans.xml&#34;);
	cachedClient &#61; (MemCachedClient)context.getBean(&#34;memcachedClient&#34;);
}

&#64;Test
public void testMemcachedSpring() {
	UserBean user &#61; new UserBean(&#34;luo&#34;, &#34;hi&#34;);
	cachedClient.set(&#34;user&#34;, user);
	UserBean cachedBean &#61; (UserBean)user;
	Assert.assertEquals(user, cachedBean);
}

}

七、注意点

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

第二、memcached的pool可以关联多个server，

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

该配置表示30%的缓存在放在第一台服务器，70%的将放在第二台服务器，这样便可以充分利用不同服务器的内存了；

第三、我最困惑的是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

和代码去流浪

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
memcached基本配置与使用

一、概念 Memcached是danga.com开发的一套分布式内存对象缓存系统，用于在动态系统中减少数据库负载，提升性能。二、原理 Memcached有两个核心组件组成：服务端（ms）和客户端（mc）。首先mc拿到ms列表，并对key做hash转化，根据hash值确定kv对所存的ms位置。然后在一个memcached的查询中，mc先通过计算key的hash值来确定kv对所处在的ms位置。当ms确定...
复制链接

扫一扫

专栏目录