Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程(daemon )是用C写的,但是客户端可以用任何语言来编写,并通过memcached协议与守护进程通信。天生支持集群。
目前有多种平台的Memcached版本,比如Linux、FreeBSD、Solaris 、Mac OS X及Windows平台。
官方网站:http://memcached.org/
我们安装Windows版本来演示。
32bit:下载 memcached-win32-1.4.4-14.zip
64bit:如果需要win64版,下载 memcached-win64-1.4.4-14.zip
Memcached 内存管理机制:
Menceched 通过预分配指定的内存空间来存取数据,所有的数据都保存在 memcached 内置的内存中。利用 Slab Allocation 机制来分配和管理内存。按照预先规定的大小,将分配的内存分割成特定长度的内存块,再把尺寸相同的内存块分成组,这些内存块不会释放,可以重复利用。当存入的数据占满内存空间时,Memcached 使用 LRU 算法自动删除不是用的缓存数据,即重用过期数据的内存空间。Memcached 是为缓存系统设计的,因此没有考虑数据的容灾问题,和机器的内存一样,重启机器将会丢失,如果希望服务重启数据依然能保留,那么就需要 sina 网开发的 Memcachedb 持久性内存缓冲系统,当然还有常见的 NOSQL 服务如 redis。默认监听端口:11211
添加新的键值对数据
从图中可以看出,Memcached虽然称为“分布式”缓存服务器,但服务器端并没有“分布式”功能,而是完全由客户端程序库实现的。服务端之间没有任何联系,数据存取都是通过客户端的算法实现的。当客户端要存取数据时,首先会通过算法查找自己维护的服务器哈希列表,找到对应的服务器后,再将数据存往指定服务器。例如:上图中应用程序要新增一个<&#8216;tokyo&#8217;,data>的键值对,它同过set操作提交给Memcached客户端,客户端通过一定的哈希算法(比如:一般的求余函数或者强大的一致性Hash算法)从服务器列表中计算出一个要存储的服务器地址,最后将该键值对存储到计算出来的服务器里边。
获取已存在的键值对数据
上图中应用程序想要获取Key为‘tokyo’的Value,于是它向Memcached客户端提交了一个Get请求,Memcached客户端还是通过算法从服务器列表查询哪台服务器存有Key为‘tokyo’的Value(即选择刚刚Set到了哪台服务器),如果查到,则向查到的服务器请求返回Key为‘tokyo’的数据。
一致性Hash算法是分布式缓存的核心理论,我也学习得不深入,也只是刚刚了解了一下,后面我有空深入学习一下。
首先,简单的路由算法(通过使用余数Hash)无法满足业务发展时服务器扩容的需要:缓存命中率下降。例如:当3台服务器扩容至4台时,采用普通的余数Hash算法会导致大约75%(3/4)被缓存了的数据无法正确命中,随着服务器集群规模的增大,这个比例会线性地上升。那么,可以想象,当100台服务器的集群中加入一台服务器,不能命中的概率大概是99%(N/N+1),这个结果显然是无法接受的。那么,能否通过改进路由算法,使得新加入的服务器不影响大部分缓存数据的正确性呢?请看下面的一致性Hash算法。
一致性Hash算法通过一个叫做一致性Hash环的数据结构实现KEY到缓存服务器的Hash映射,如下图所示:
具体算法过程是:
因此,我们可以与之前的普通余数Hash作对比:采用一致性Hash算法时,当3台服务器扩容到4台时,可以继续命中原有缓存数据的概率为75%,远高于普通余数Hash的25%,而且随着集群规模越大,继续命中原有缓存数据的概率也会随之增大。当100台服务器增加1台时,继续命中的概率是99%。
虽然,仍有小部分数据缓存在服务器中无法被读取到,但是这个比例足够小,通过访问数据库也不会对数据库造成致命的负载压力。
因此,我们可以得出一个结论:在简单的Key/Value应用场景(例如缓存),Memcached拥有更高的读写性能;而在数据持久化和数据同步场景,Redis拥有更加强大的功能和更为丰富的数据类型;
需要慎重考虑的部分
memcached.exe -d install
memcached.exe -d start
memcached.exe -d stop
memcached.exe -d uninstall
以上的安装和启动都是在默认环境下进行的,在安装时可设置如下参数:
Memcached默认使用端口是11211
默认最大连接数是1024个
默认最大使用内存是64M
默认每个键值对,值存储空间为1M
-p 监听的端口
-l 连接的IP地址, 默认是本机
-d start 启动memcached服务
-d restart 重起memcached服务
-d stop|shutdown 关闭正在运行的memcached服务
-d install 安装memcached服务
-d uninstall 卸载memcached服务
-u 以身份运行 (仅在以root运行的时候有效)
-m 最大内存使用,单位MB。默认64MB **
-M 内存耗尽时返回错误,而不是删除项
-c 最大同时连接数,默认是1024 **
-f 块大小增长因子,默认是1.25
-n 最小分配空间,key+value+flags默认是48
-h 显示帮助
OK,命令咱们已经执行完了.怎么才知道Memcached服务已经安装成功并启动了呢?
cmd 命令 services.msc
检测Memcached服务是否成功启动:
先把memcached用起来使用telnet命令连接到登录台:telnet 服务器IP地址 11211(11211是默认的Memcached服务端口号)
打印当前Memcache服务器状态:statsstats.png
可以看到,通过stats命令列出了一系列的Memcached服务状态信息,那么这些信息又代表什么意思呢?我们可以通过下图来知道:
下载客户端的4个dll,
ICSharpCode.SharpZipLib.dll,log4net.dll,Memcached.ClientLibrary.dll,Commons.dll
跟着我新建一个简单控制台应用程序
using Memcached.ClientLibrary;
细品 .NET Memcached.ClientLibrary
using System;
namespace Tdf.RedisCacheTest
{
class AMemcached
{
public static MemcachedClient cache;
static AMemcached()
{
string[] servers = { "127.0.0.1:11211" };
// 初始化池
SockIOPool pool = SockIOPool.GetInstance();
// 设置服务器列表
pool.SetServers(servers);
// 各服务器之间负载均衡的设置比例
pool.SetWeights(new int[] { 1 });
// 初始化时创建连接数
pool.InitCOnnections= 3;
// 最小连接数
pool.MinCOnnections= 3;
// 最大连接数
pool.MaxCOnnections= 5;
// 连接的最大空闲时间,下面设置为6个小时(单位ms),超过这个设置时间,连接会被释放掉
pool.MaxIdle = 1000 * 60 * 60 * 6;
// socket连接的超时时间,下面设置表示不超时(单位ms),即一直保持链接状态
pool.SocketCOnnectTimeout= 0;
// 通讯的超时时间,下面设置为3秒(单位ms),.Net版本没有实现
pool.SocketTimeout = 1000 * 3;
// 维护线程的间隔激活时间,下面设置为30秒(单位s),设置为0时表示不启用维护线程
pool.MaintenanceSleep = 30;
// 设置SocktIO池的故障标志
pool.Failover = true;
// 是否对TCP/IP通讯使用nalgle算法,.net版本没有实现
pool.Nagle = false;
// socket单次任务的最大时间(单位ms),超过这个时间socket会被强行中端掉,当前任务失败。
pool.MaxBusy = 1000 * 10;
pool.Initialize();
cache = new MemcachedClient();
// 是否启用压缩数据:如果启用了压缩,数据压缩长于门槛的数据将被储存在压缩的形式
cache.EnableCompression = false;
// 压缩设置,超过指定大小的都压缩
cache.CompressiOnThreshold= 1024 * 1024;
}
}
class Program
{
static void Main(string[] args)
{
// 存入key为userName,value为Bobby的一个缓存
AMemcached.cache.Add("userName", "Bobby");
// 读出key为a的缓存值
var s = AMemcached.cache.Get("userName");
// 输出
Console.WriteLine(s);
Console.Read();
}
}
}
string[] servers = { "127.0.0.1:11211", "192.168.2.100:11211" };
// 初始化池
SockIOPool pool = SockIOPool.GetInstance();
// 设置服务器列表
pool.SetServers(servers);
// 各服务器之间负载均衡的设置比例
pool.SetWeights(new int[] { 1, 10 });
Note:
// 是否启用压缩数据:如果启用了压缩,数据压缩长于门槛的数据将被储存在压缩的形式
cache.EnableCompression = false;
// 压缩设置,超过指定大小的都压缩
cache.CompressiOnThreshold= 1024 * 1024;
Note:
using Memcached.ClientLibrary;
using System;
namespace Tdf.RedisCacheTest
{
class AMemcached
{
public MemcachedClient cache;
public AMemcached(string poolName)
{
string[] servers = { "127.0.0.1:11211", "192.168.2.100:11211" };
// 初始化池
SockIOPool pool = SockIOPool.GetInstance();
// 设置服务器列表
pool.SetServers(servers);
// 各服务器之间负载均衡的设置比例
pool.SetWeights(new int[] { 1, 10 });
// 初始化时创建连接数
pool.InitCOnnections= 3;
// 最小连接数
pool.MinCOnnections= 3;
// 最大连接数
pool.MaxCOnnections= 5;
// 连接的最大空闲时间,下面设置为6个小时(单位ms),超过这个设置时间,连接会被释放掉
pool.MaxIdle = 1000 * 60 * 60 * 6;
// socket连接的超时时间,下面设置表示不超时(单位ms),即一直保持链接状态
pool.SocketCOnnectTimeout= 0;
// 通讯的超时时间,下面设置为3秒(单位ms),.Net版本没有实现
pool.SocketTimeout = 1000 * 3;
// 维护线程的间隔激活时间,下面设置为30秒(单位s),设置为0时表示不启用维护线程
pool.MaintenanceSleep = 30;
// 设置SocktIO池的故障标志
pool.Failover = true;
// 是否对TCP/IP通讯使用nalgle算法,.net版本没有实现
pool.Nagle = false;
// socket单次任务的最大时间(单位ms),超过这个时间socket会被强行中端掉,当前任务失败。
pool.MaxBusy = 1000 * 10;
pool.Initialize();
cache = new MemcachedClient();
// 是否启用压缩数据:如果启用了压缩,数据压缩长于门槛的数据将被储存在压缩的形式
cache.EnableCompression = false;
// 压缩设置,超过指定大小的都压缩
cache.CompressiOnThreshold= 1024 * 1024;
}
}
class Program
{
static void Main(string[] args)
{
// 存入key为userName,value为Bobby的一个缓存
new AMemcached("poolName").cache.Add("b", 123);
// AMemcached.cache.Add("userName", "Bobby");
// 读出key为a的缓存值
var s = new AMemcached("poolName").cache.Get("userName");
// 输出
Console.WriteLine(s);
Console.Read();
}
}
}
// 设置SocktIO池的故障标志
pool.Failover = true;
Note:memcached的鼓掌转移是一套正常节点发生故障变为死节点时的处理机制。
- key在服务端的长度限制为250个字符,建议使用较短的key但不要重复。
using System;
namespace Tdf.Memcached
{
public interface IMemcached
{
void Add(string key, object value);
void Add(string key, object value, DateTime expiredDateTime);
void Update(string key, object value);
void Update(string key, object value, DateTime expiredDateTime);
void Set(string key, object value);
void Set(string key, object value, DateTime expiredTime);
void Delete(string key);
object Get(string key);
bool KeyExists(string key);
}
}
using Memcached.ClientLibrary;
using System;
using System.Configuration;
namespace Tdf.Memcached
{
///
/// 基于Memcached.ClientLibrary封装使用Memchached信息
/// 读取缓存存放在服务器
///
public class MemcacheHelper
{
///
/// 字段_instance,存放注册的缓存信息
///
private static MemcacheHelper _instance;
///
/// 缓存客户端
///
private readonly MemcachedClient _client;
///
/// 受保护类型的缓存对象,初始化一个新的缓存对象
///
protected MemcacheHelper()
{
// 读取app.Config中需要缓存的服务器地址信息,可以传递多个地址,使用";"分隔
string[] serverList = ConfigurationManager.AppSettings["readWriteHosts"].Split(new char[] { ';' });
try
{
// 初始化池
var sockIoPool = SockIOPool.GetInstance();
// 设置服务器列表
sockIoPool.SetServers(serverList);
// 各服务器之间负载均衡的设置比例
sockIoPool.SetWeights(new int[] { 1 });
// 初始化时创建连接数
sockIoPool.InitCOnnections= 3;
// 最小连接数
sockIoPool.MinCOnnections= 3;
// 最大连接数
sockIoPool.MaxCOnnections= 5;
// 连接的最大空闲时间,下面设置为6个小时(单位ms),超过这个设置时间,连接会被释放掉
sockIoPool.MaxIdle = 1000 * 60 * 60 * 6;
// socket连接的超时时间,下面设置表示不超时(单位ms),即一直保持链接状态
sockIoPool.SocketCOnnectTimeout= 0;
// 通讯的超时时间,下面设置为3秒(单位ms),.Net版本没有实现
sockIoPool.SocketTimeout = 1000 * 3;
// 维护线程的间隔激活时间,下面设置为30秒(单位s),设置为0时表示不启用维护线程
sockIoPool.MaintenanceSleep = 30;
// 设置SocktIO池的故障标志
sockIoPool.Failover = true;
// 是否对TCP/IP通讯使用nalgle算法,.net版本没有实现
sockIoPool.Nagle = false;
// socket单次任务的最大时间(单位ms),超过这个时间socket会被强行中端掉,当前任务失败。
sockIoPool.MaxBusy = 1000 * 10;
sockIoPool.Initialize();
// 实例化缓存对象
_client = new MemcachedClient();
// 是否启用压缩数据:如果启用了压缩,数据压缩长于门槛的数据将被储存在压缩的形式
_client.EnableCompression = false;
// 压缩设置,超过指定大小的都压缩
_client.CompressiOnThreshold= 1024 * 1024;
}
catch (Exception ex)
{
// 错误信息写入事务日志
throw new Exception(ex.Message);
}
}
///
/// 获取缓存的实例对象,方法调用的时候使用
///
///
public static MemcacheHelper GetInstance()
{
return _instance;
}
///
/// 添加缓存信息(如果存在缓存信息则直接重写设置,否则添加)
/// 使用:MemcacheHelper.GetInstance().Add(key,value)
///
/// 需要缓存的键
/// 需要缓存的值
public void Add(string key, object value)
{
if (_client.KeyExists(key))
{
_client.Set(key, value);
}
_client.Add(key, value);
}
///
/// 添加缓存信息
/// 使用:MemcacheHelper.GetInstance().Add(key,value,Datetime.Now())
///
/// 需要缓存的键
/// 需要缓存的值
/// 设置的缓存的过时时间
public void Add(string key, object value, DateTime expiredDateTime)
{
_client.Add(key, value, expiredDateTime);
}
///
/// 修改缓存的值
/// 使用:MemcacheHelper.GetInstance().Update(key,value)
///
/// 需要修改的键
/// 需要修改的值
public void Update(string key, object value)
{
_client.Replace(key, value);
}
///
/// 修改缓存的值
/// 使用:MemcacheHelper.GetInstance().Update(key,value,Datetime.Now())
///
/// 需要修改的键
/// 需要修改的值
/// 设置的缓存的过时时间
public void Update(string key, object value, DateTime expiredDateTime)
{
_client.Replace(key, value, expiredDateTime);
}
///
/// 设置缓存
/// 使用:MemcacheHelper.GetInstance().Set(key,value)
///
/// 设置缓存的键
/// 设置缓存的值
public void Set(string key, object value)
{
_client.Set(key, value);
}
///
/// 设置缓存,并修改过期时间
/// 使用:MemcacheHelper.GetInstance().Set(key,value,Datetime.Now())
///
/// 设置缓存的键
/// 设置缓存的值
/// 设置缓存过期的时间
public void Set(string key, object value, DateTime expiredTime)
{
_client.Set(key, value, expiredTime);
}
///
/// 删除缓存
/// 使用:MemcacheHelper.GetInstance().Delete(key)
///
/// 需要删除的缓存的键
public void Delete(string key)
{
_client.Delete(key);
}
///
/// 获取缓存的值
/// 使用:MemcacheHelper.GetInstance().Get(key)
///
/// 传递缓存中的键
///
public object Get(string key)
{
return _client.Get(key);
}
///
/// 缓存是否存在
/// 使用:MemcacheHelper.GetInstance().KeyExists(key)
///
/// 传递缓存中的键
///
public bool KeyExists(string key)
{
return _client.KeyExists(key);
}
///
/// 注册Memcache缓存(在Global.asax的Application_Start方法中注册)
/// 使用:MemcacheHelper.RegisterMemcache();
///
public static void RegisterMemcache()
{
if (_instance == null)
{
_instance = new MemcacheHelper();
}
}
}
}
using System;
using Tdf.Memcached;
namespace Tdf.MemcachedTest
{
class Program
{
static void Main(string[] args)
{
// 注册Memcache缓存
MemcacheHelper.RegisterMemcache();
// 添加缓存信息(如果存在缓存信息则直接重写设置,否则添加)
MemcacheHelper.GetInstance().Add("userName", "Bobby");
// 缓存是否存在
var tf = MemcacheHelper.GetInstance().KeyExists("userName");
Console.WriteLine(tf);
// 获取缓存的值
var s = MemcacheHelper.GetInstance().Get("userName");
Console.WriteLine(s);
Console.Read();
}
}
}
到此,我们已经完成了一个最小化的memcached集群读写测试Demo。但是,在实际的开发场景中,远不仅仅是存储一个字符串,更多的是存储一个自定义的类的实例对象。这就需要使用到序列化,下面我们来新加一个类Claim,让其作为可序列化的对象来存储进Memcached中。注意:需要为该类加上[Serializable]的特性!
using System;
using Tdf.Memcached;
namespace Tdf.MemcachedTest
{
[Serializable]
public class Claim
{
public int UserId { get; set; }
public string UserName { get; set; }
}
class Program
{
static void Main(string[] args)
{
// 注册Memcache缓存
MemcacheHelper.RegisterMemcache();
// 自定义对象存储
Claim claim = new Claim();
claim.UserId = 694802856;
claim.UserName = "难念的经";
MemcacheHelper.GetInstance().Add("Claim", claim);
Claim newMyObj = MemcacheHelper.GetInstance().Get("Claim") as Claim;
Console.WriteLine("Hello,My UserId is {0} and UserName is {1}", newMyObj.UserId, newMyObj.UserName);
Console.Read();
}
}
}