[原创] Memcache分组和同步机制的实现
作者:heiyeluren
博客:http://blog.csdn.net/heiyeshuwu
时间:2007-06-25
【Memcache同步类的实现思想】
首先我们明确了解就是Memcache是一个简单、快速、高效的分布式基于内存的缓存工具,一般用于网站等数据库数据缓存、高速交换信息的缓存,比如Session数据等等。Memcache最主要的特点就是两个:一是它是基于内存的高效Hash类缓存方式,二是使用了LUR算法来进行数据有效期控制,这两点就能够很好的满足我们的普通网站的应用。(关于Memcache的使用和协议请参考我的另一篇文章:《Memcache的使用和协议分析详解》http://blog.csdn.net/heiyeshuwu/archive/2006/11/13/1380838.aspx)
Memcache本身也存在一些不足,不能说是不足,至少是为了满足它高效的存取,所以没有去实现的功能,包括:一是本身没有内置分布式功能,无法实现使用多台Memcache服务器来存储不同的数据,最大程度的使用相同的资源;二是无法同步数据,容易造成单点故障。
那么其实都可以通过我们的Memcache的客户端程序来解决的,首先我们PHP的PECL中的Memcache扩展能够有效的解决Memcache的分布式问题,主要的接口就是 addServer() 函数,具体关于addServer()函数的实现可以参考该扩展源代码。那么现在就存在第二个问题,就是说无法同步数据,可以理解为MySQL中Master/Slave的机制,就是说如果我们有多台的Memcache服务器,使用addServer函数的话,每个服务器存储的数据都是唯一的,那么任何一台服务器宕机的话,那么这台服务器上的存储数据将丢失无法访问,这样肯定是无法充分发挥我们Memcache威力的,那么我们就需要一个方式来解决这个问题,这个就是本文主要要探讨解决的问题:关于在多台Memcache服务器中分组和同步数据的问题。
针对这个问题我构建了一个PHP写的Class,大致的思想就是把多台Memcache服务器分成两组,每组的服务器数量可能是一样的(如果总数是复数的话),数量不一样也没关系,写数据的时候往两组服务器都写,数据是一样的,那么A组服务器的数据和B组服务器的数据是一样的,如果A组服务器中某一台机器宕机了,则能够从B组服务器中提取出数据来,这样能够有效的避免单点故障,特别是在高性能要求的网站当中。当然,相应的操作也是有开销的,主要的开销在于网络连接,就是说连接到A组服务器中发现没有数据,则去访问B组服务器。另外还有就是在访问数据过程中,都是从A组开始的,那么并发量很高的情况下,A组服务器的压力比较大,那么我还实现了对A组和B组服务器随机访问的机制,如果在随机的组中没有发现数据则访问另外一个组,这样A组和B组的压力就是1/2了,能够有效的面对高负载的情况。
同样的,这个类是可以扩展的,比如你可以修改成为能够满足两组以上的服务器,但是这样逻辑会更复杂,我基于简便期间,目前就考虑了两组服务器的情况,毕竟一般公司来说,没有很多机器去做Memcache的缓存,所以两组已经能够满足大部分要求了。
PS:如果有兴趣的话,可以完全自己重新实现Memcache的addServer扩展,比如增加addGroup之类的方法,能够更有效的解决同步和分组的问题。同样的,如果想节省资源的使用,可以把Memcached当作线程的方式来运行。
【Memcache同步类的实现代码】
本类经过我大致的各种测试,运行还算稳定,当然,使用时还是请多加注意。
/* *
* Memcache 操作类 (支持同步和分组访问)
*
* author : heiyeluren <http://blog.csdn.net/heiyeshuwu>
* created : 2007-06-21
* lastModifed: 2007-06-21
*/
/* *
* Memcache操作类
*/
class MemcacheOpt
{
// ---------------------
// 属性定义
//---------------------
/* *
* 是否进行多组同步
*/
var $isGroup = true ;
/* *
* 多组同步情况下是否使用减轻负载的随机存取
*/
var $isRandom = true ;
/* *
* 默认的Memcache服务器端口
*/
var $mmcPort = 11211 ;
/* *
* 保存原始组信息
*/
var $groups = array ();
/* *
* 保存第一、二组Memcache服务器信息
*/
var $group1 = array ();
var $group2 = array ();
/* *
* 保存第一、二组连接对象
*/
var $mmc1 = '' ;
var $mmc2 = '' ;
// ---------------------
// 内部操作方法
//---------------------
/* *
* 显示错误信息
*
* @param string $msg 需要显示消息的内容
* @param string $type 消息类型,error是普通错误消息,fatal 是致命错误,将终止程序执行, message 是普通消息,缺省状
态
* @return bool true
*/
function showMessage( $msg , $type ){
$msg .= " " ;
switch ( $type ){
case ' error ' :
echo ( " Memcache Error: " . $msg );
break ;
case ' fatal ' :
die ( " Memcache Fatal: " . $msg );
break ;
case ' message ' :
echo ( " Memcache Message: " . $msg );
break ;
default :
echo ( " Memcache Error: " . $msg );
}
return true ;
}
/* *
* 构造函数 (初始化分组和连接到服务器)
*/
function MemcacheOpt( $hostArray , $hostArray2 = array ()){
if ( ! is_array ( $hostArray ) || empty ( $hostArray )){
$this -> showMessage( ' Memcache host list invalid ' , ' fatal ' );
}
$this -> groups = array_merge ( $hostArray , $hostArray2 );
$this -> splitGroup( $hostArray , $hostArray2 );
$this -> connect();
}
/* *
* 对组进行切分 (按照是否需要分组进行相应的切分)
*
* @param array $hostArray 主机数组列表1
* @param array $hostArray2 主机数组列表2
* @return void
*/
function splitGroup( $hostArray , $hostArray2 = array ()){
// 如果只有一台机器则不使用分组
if ( count ( $hostArray ) < 2 && empty ( $hostArray2 )){
$this -> isGroup = false ;
}
// 使用分组
if ( $this -> isGroup){
if ( is_array ( $hostArray2 ) && ! empty ( $hostArray2 )){
$this -> group1 = $hostArray ;
$this -> group2 = $hostArray2 ;
} else {
$count = ceil ( count ( $hostArray ) / 2 );
$this -> group1 = array_splice ( $hostArray , 0 , $count );
$this -> group2 = array_splice ( $hostArray , 0 );
}
} else {
$this -> group1 = $hostArray ;
}
}
/* *
* 连接到Memcache服务器
*/
function connect(){
if ( ! is_array ( $this -> group1) || empty ( $this -> group1)){
$this -> showMessage( " Memcache host1 array invalid " , ' error ' );
return false ;
}
// 连接第一组Memcache服务器
$this -> mmc1 = new Memcache;
foreach ( $this -> group1 as $hosts ){
$tmp = explode ( " : " , $hosts );
$host = $tmp [ 0 ];
$port = ( ! isset ( $tmp [ 1 ]) || $tmp [ 1 ] == '' ) ? $this -> mmcPort : $tmp [ 1 ];
$this -> mmc1 -> addServer( $host , $port );
}
// 如果需要分组则连接第二组Memcache服务器
if ( $this -> isGroup){
if ( ! is_array ( $this -> group2) || empty ( $this -> group2) ){
$this -> showMessage( " Memcache host2 array invalid " , ' error ' );
return false ;
}
$this -> mmc2 = new Memcache;
foreach ( $this -> group2 as $hosts ){
$tmp = explode ( " : " , $hosts );
$host = $tmp [ 0 ];
$port = ( ! isset ( $tmp [ 1 ]) || $tmp [ 1 ] == '' ) ? $this -> mmcPort : $tmp [ 1 ];
$this -> mmc2 -> addServer( $host , $port );
}
}
}
/* *
* 关闭Memcache服务器连接
*/
function close(){
if ( is_object ( $this -> mmc1)){
$this -> mmc1 -> close();
}
if ( is_object ( $this -> mmc1)){
$this -> mmc1 -> close();
}
return true ;
}
/* *
* 数据操作核心函数
*
* @param string $optType 操作类型,主要有 add, set, replace, delete, flush
* @param string $key 关键字,如果是 add,set,replace,delete 需要提交key参数
* @param string $val 关键字对应的值,如果是 add, set,replace 需要提交value参数
* @param int $expire 数据有效期,如果是 add,set,replace需要提交expire参数
* @return mixed 不同的需要产生不同的返回
*/
function opt( $optType , $key = '' , $val = '' , $expire = '' ){
if ( ! is_object ( $this -> mmc1)){
$this -> showMessage( " Not availability memcache connection object " , ' fatal ' );
}
if ( $this -> isGroup && ! is_object ( $this -> mmc2)){
$this -> showMessage( " Group 2 memcache host connection object not availability " , ' error ' );
}
// 加入数据操作
if ( $optType == ' add ' || $optType == ' set ' || $optType == ' replace ' ){
$this -> mmc1 -> set( $key , $val , false , $expire );
if ( $this -> isGroup && is_object ( $this -> mmc2)){
$this -> mmc2 -> set( $key , $val , false , $expire );
}
return true ;
}
// 获取数据操作
if ( $optType == ' get ' ){
// 缺省获取第一组数据
if ( ! $this -> isGroup || ! is_object ( $this -> mmc2)){
return $this -> mmc1 -> get( $key );
}
// 分组情况下逐组访问
$num = ( $this -> isRandom ? rand ( 1 , 2 ) : 1 );
$obj = " mmc " . $num ;
$val = $this -> $obj -> get( $key );
// 如果没有提取到数据,则访问另外一组
if ( $val == "" ){
switch ( $num ){
case 1 : $val = $this -> mmc2 -> get( $key ); break ;
case 2 : $val = $this -> mmc1 -> get( $key ); break ;
default : $val = $this -> mmc1 -> get( $key );
}
}
return $val ;
}
// 删除数据操作
if ( $optType == ' delete ' ){
$this -> mmc1 -> delete( $key , $expire );
if ( $this -> isGroup && is_object ( $this -> mmc2)){
$this -> mmc2 -> delete( $key );
}
return true ;
}
// 清空数据操作
if ( $optType == ' flush ' ){
$this -> mmc1 -> flush ();
if ( $this -> isGroup && is_object ( $this -> mmc2)){
$this -> mmc2 -> flush ();
}
return true ;
}
}
// ---------------------
// 外部操作方法
//---------------------
//增加一个元素
function add( $key , $val , $expire = '' ){
return $this -> opt( ' add ' , $key , $val , $expire );
}
// 增加一个元素
function set( $key , $val , $expire = '' ){
return $this -> opt( ' set ' , $key , $val , $expire );
}
// 替换一个元素
function replace( $key , $val , $expire = '' ){
return $this -> opt( ' replace ' , $val , $expire );
}
// 获取一个元素
function get( $key ){
return $this -> opt( ' get ' , $key );
}
// 删除一个元素
function delete( $key , $timeout = '' ){
return $this -> opt( ' delete ' , $key , '' , $timeout );
}
// 让所有的元素过期 (本接口不要轻易使用)
function flush (){
return $this -> opt( ' flush ' );
}
/* *
* 获取所有Memcache服务器状态
*/
function getStats(){
$status = array ();
// 单独连接到每台Memcache
foreach ( $this -> groups as $key => $hosts ){
$tmp = explode ( " : " , $hosts );
$host = $tmp [ 0 ];
$port = ( ! isset ( $tmp [ 1 ]) || $tmp [ 1 ] == '' ) ? $this -> mmcPort : $tmp [ 1 ];
$conn = new Memcache;
$conn -> connect( $host , $port );
$s = $conn -> getStats();
$s [ ' host ' ] = $host ;
$s [ ' port ' ] = $port ;
$status [ $key ] = $s ;
}
return $status ;
}
/* *
* 获取所有Memcache服务器版本号
*/
function getVersion(){
$version = array ();
$stats = $this -> getStats();
foreach ( $stats as $key => $s ){
$v [ ' host ' ] = $s [ ' host ' ];
$v [ ' port ' ] = $s [ ' port ' ];
$v [ ' version ' ] = $s [ ' version ' ];
$version [ $key ] = $v ;
}
return $version ;
}
}
?>
【Memcache同步类的测试】
在本机开启多个Memcache守护进程:
heiyeluren 98466 0.0 0.2 6088 5676 ?? SsJ 7 :50下午 0 : 00.04 /usr/local/memcache/bin/memcached -d -m 32 -l 10.62.240.9 -p 11214
heiyeluren 98437 0.0 0.2 6088 5676 ?? SsJ 7 :50下午 0 : 00.04 /usr/local/memcache/bin/memcached -d -m 32 -l 10.62.240.9 -p 11213
heiyeluren 98425 0.0 0.2 6088 5676 ?? SsJ 7 :50下午 0 : 00.05 /usr/local/memcache/bin/memcached -d -m 32 -l 10.62.240.9 -p 11212
heiyeluren 98228 0.0 0.2 6088 5676 ?? SsJ 7 :48下午 0 : 00.05 /usr/local/memcache/bin/memcached -d -m 32 -l 10.62.240.9 -p 11211
MemcacheOpt类测试代码:
require_once ( " MemcacheOpt.class.php " );
// 操作代码
$hostArray = array ( " 10.62.240.9 " , " 10.62.240.9:11212 " , " 10.62.240.9:11213 " , " 10.62.240.9:11214 " );
$m = new MemcacheOpt( $hostArray );
$m -> add( " key1 " , " key1_value " , 30 );
$m -> add( " key2 " , " key2_value " , 30 );
$m -> set( " key3 " , " key3_value " , 30 );
$m -> set( " key4 " , " key4)value " , 30 );
echo $m -> get( " key1 " ) . " " ;
echo $m -> get( " key2 " ) . " " ;
echo $m -> get( " key3 " ) . " " ;
echo $m -> get( " key4 " ) . " " ;
print_r ( $m -> getStats());
print_r ( $m -> getVersion());
?>
测试代码输出结果:
key2_value
key3_value
key4)value
Array
(
[ 0 ] = > Array
(
[ pid ] = > 98228
[ uptime ] = > 7440
[ time ] = > 1182433964
[ version ] = > 1.1.12
[ rusage_user ] = > 0.024758
[ rusage_system ] = > 0.034309
[ curr_items ] = > 5
[ total_items ] = > 158
[ bytes ] = > 265
[ curr_connections ] = > 3
[ total_connections ] = > 134
[ connection_structures ] = > 4
[ cmd_get ] = > 87
[ cmd_set ] = > 159
[ get_hits ] = > 81
[ get_misses ] = > 6
[ bytes_read ] = > 6423
[ bytes_written ] = > 27628
[ limit_maxbytes ] = > 33554432
[ host ] = > 10.62.240.9
[ port ] = > 11211
)
[ 1 ] = > Array
(
[ pid ] = > 98425
[ uptime ] = > 7359
[ time ] = > 1182433964
[ version ] = > 1.1.12
[ rusage_user ] = > 0.012727
[ rusage_system ] = > 0.038181
[ curr_items ] = > 4
[ total_items ] = > 119
[ bytes ] = > 208
[ curr_connections ] = > 3
[ total_connections ] = > 121
[ connection_structures ] = > 4
[ cmd_get ] = > 45
[ cmd_set ] = > 122
[ get_hits ] = > 45
[ get_misses ] = > 0
[ bytes_read ] = > 4492
[ bytes_written ] = > 22146
[ limit_maxbytes ] = > 33554432
[ host ] = > 10.62.240.9
[ port ] = > 11212
)
[ 2 ] = > Array
(
[ pid ] = > 98437
[ uptime ] = > 7356
[ time ] = > 1182433964
[ version ] = > 1.1.12
[ rusage_user ] = > 0.029343
[ rusage_system ] = > 0.022345
[ curr_items ] = > 4
[ total_items ] = > 84
[ bytes ] = > 213
[ curr_connections ] = > 3
[ total_connections ] = > 111
[ connection_structures ] = > 4
[ cmd_get ] = > 88
[ cmd_set ] = > 85
[ get_hits ] = > 43
[ get_misses ] = > 45
[ bytes_read ] = > 4014
[ bytes_written ] = > 23911
[ limit_maxbytes ] = > 33554432
[ host ] = > 10.62.240.9
[ port ] = > 11213
)
[ 3 ] = > Array
(
[ pid ] = > 98466
[ uptime ] = > 7330
[ time ] = > 1182433964
[ version ] = > 1.1.12
[ rusage_user ] = > 0.009188
[ rusage_system ] = > 0.035360
[ curr_items ] = > 1
[ total_items ] = > 53
[ bytes ] = > 52
[ curr_connections ] = > 3
[ total_connections ] = > 98
[ connection_structures ] = > 4
[ cmd_get ] = > 37
[ cmd_set ] = > 56
[ get_hits ] = > 28
[ get_misses ] = > 9
[ bytes_read ] = > 2437
[ bytes_written ] = > 21024
[ limit_maxbytes ] = > 33554432
[ host ] = > 10.62.240.9
[ port ] = > 11214
)
)
Array
(
[ 0 ] = > Array
(
[ host ] = > 10.62.240.9
[ port ] = > 11211
[ version ] = > 1.1.12
)
[ 1 ] = > Array
(
[ host ] = > 10.62.240.9
[ port ] = > 11212
[ version ] = > 1.1.12
)
[ 2 ] = > Array
(
[ host ] = > 10.62.240.9
[ port ] = > 11213
[ version ] = > 1.1.12
)
[ 3 ] = > Array
(
[ host ] = > 10.62.240.9
[ port ] = > 11214
[ version ] = > 1.1.12
)
)
【结束语】
最后提出两个使用Memcache的小技巧,第一个是如果是一个有效分布式存储的数据,key的取名是很有学问的,这个可以按照项目需要去做,但是key值不要太长,不会冲突就行。第二个就是每个保存在memcache中的数据不要超过1MB。第三个就是开启一个Memcache进程设置内存不要太多也不要太少,按照自己合适设置就行,尽量最大程度提高对硬件的使用,同样可以采取在一台服务器上开启多个memcached来分担一个memcached并发链接的压力。更多技巧在实际使用长慢慢去总结发现,会发现其实memcahe虽然简单,但是很好用。
本文总的就是发现一些简单的东西,可以通过自主扩展的方式来发现更多有趣实用的功能,我想,这就是开源产品的魅力所在吧。欢迎提出批评或者是更好的实现方式。