Linux下MemCached安装和启动以及C#调用

于 2013-02-19 09:08:24 发布
阅读量408 收藏
点赞数
分类专栏： ※Linux※

一、Linux下MemCached安装和启动

如果是centos可以yum安装

# yum install libevent-devel

如果不支持yum的系统，可以这样装libevent

# cd /usr/local/src 
# wget http://www.monkey.org/~provos/libevent-1.4.12-stable.tar.gz 
# tar vxf libevent-1.4.12-stable.tar.gz 
# cd libevent-1.4.12 
# ./configure --prefix=/usr/local/libevent 
# make && make install

继续安装memcached

# cd /usr/local/src 
# wget http://cloud.github.com/downloads/saberma/saberma.github.com/memcached-1.4.4.tar.gz 
# tar vxf memcached-1.4.4.tar.gz 
# cd memcached-1.4.4 
# ./configure --prefix=/usr/local/memcached 
# make && make install

 

安装完后启动memcached并分配1024m内存

/usr/local/memcached/bin/memcached -d -m 1024 –l 10.32.33.120 -p 11211 -u root

-d选项是启动一个守护进程， 
-m是分配给Memcache使用的内存数量，单位是MB，我这里是10MB， 
-u是运行Memcache的用户，我这里是root， 
-l是监听的服务器IP地址，如果有多个地址的话，我这里指定了服务器的IP地址10.32.33.120， 
-p是设置Memcache监听的端口，我这里设置了12000，最好是1024以上的端口， 
-c选项是最大运行的并发连接数，默认是1024，我这里设置了256，按照你服务器的负载量来设定， 
-P是设置保存Memcache的pid文件，我这里是保存在 /tmp/memcached.pid，

将memcached加入启动项

# vi /etc/rc.d/rc.local

在最后加入

/usr/local/memcached/bin/memcached -d -m 1024 –l 10.32.33.120 -p 11211 -u root

按Esc键，再输入

：wq

保存退出

 

查看是否启动memcached

获取运行状态：echo stats | nc 10.32.33.120 11211(可以查看出pid) 或使用ps -ef|grep memcached

如果要结束Memcache进程，执行：

# kill `cat /tmp/memcached.pid`

也可以

#kill –9 进程号

二、连接到 memcached

连接到 memcached： 
telnet ip 端口，如telnet 10.32.33.120 11211 
stats查看状态，flush_all:清楚缓存 
查看memcached状态的基本命令，通过这个命令可以看到如下信息： 
STAT pid 22459 进程ID 
STAT uptime 1027046 服务器运行秒数 
STAT time 1273043062 服务器当前unix时间戳 
STAT version 1.4.4 服务器版本 
STAT pointer_size 64 操作系统字大小(这台服务器是64位的) 
STAT rusage_user 0.040000 进程累计用户时间 
STAT rusage_system 0.260000 进程累计系统时间 
STAT curr_connections 10 当前打开连接数 
STAT total_connections 82 曾打开的连接总数 
STAT connection_structures 13 服务器分配的连接结构数 
STAT cmd_get 54 执行get命令总数 
STAT cmd_set 34 执行set命令总数 
STAT cmd_flush 3 指向flush_all命令总数 
STAT get_hits 9 get命中次数 
STAT get_misses 45 get未命中次数 
STAT delete_misses 5 delete未命中次数 
STAT delete_hits 1 delete命中次数 
STAT incr_misses 0 incr未命中次数 
STAT incr_hits 0 incr命中次数 
STAT decr_misses 0 decr未命中次数 
STAT decr_hits 0 decr命中次数 
STAT cas_misses 0 cas未命中次数 
STAT cas_hits 0 cas命中次数 
STAT cas_badval 0 使用擦拭次数 
STAT auth_cmds 0 
STAT auth_errors 0 
STAT bytes_read 15785 读取字节总数 
STAT bytes_written 15222 写入字节总数 
STAT limit_maxbytes 1048576 分配的内存数（字节） 
STAT accepting_conns 1 目前接受的链接数 
STAT listen_disabled_num 0 
STAT threads 4 线程数 
STAT conn_yields 0 
STAT bytes 0 存储item字节数 
STAT curr_items 0 item个数 
STAT total_items 34 item总数 
STAT evictions 0 为获取空间删除item的总数

三、c#调用

MemCache管理操作类,MemCachedManager.cs文件：

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
using  System;
using  System.Collections;
using  System.Data;
using  System.Data.Common;
using  System.IO;
using  Memcached.ClientLibrary;
namespace  Plugin.Cache
{
     /// <summary>
     /// MemCache管理操作类
     /// </summary>
     public  sealed  class  MemCachedManager
     {
         #region 静态方法和属性
         private  static  MemcachedClient mc =  null ;
         private  static  SockIOPool pool =  null ;
         private  static  string [] serverList =  null ;
         private  static  MemCachedConfigInfo memCachedConfigInfo = MemCachedConfig.GetConfig();
   
         #endregion
  
         static  MemCachedManager()
         {
             CreateManager();
         }
  
         private  static  void  CreateManager()
         {
             serverList = memCachedConfigInfo.ServerList;
             pool = SockIOPool.GetInstance(memCachedConfigInfo.PoolName);
             pool.SetServers(serverList);
             pool.InitConnections = memCachedConfigInfo.IntConnections; //初始化链接数
             pool.MinConnections = memCachedConfigInfo.MinConnections; //最少链接数
             pool.MaxConnections = memCachedConfigInfo.MaxConnections; //最大连接数
             pool.SocketConnectTimeout = memCachedConfigInfo.SocketConnectTimeout; //Socket链接超时时间
             pool.SocketTimeout = memCachedConfigInfo.SocketTimeout; // Socket超时时间
             pool.MaintenanceSleep = memCachedConfigInfo.MaintenanceSleep; //维护线程休息时间
             pool.Failover = memCachedConfigInfo.FailOver;  //失效转移(一种备份操作模式)
             pool.Nagle = memCachedConfigInfo.Nagle; //是否用nagle算法启动socket
             pool.HashingAlgorithm = HashingAlgorithm.NewCompatibleHash;
   
             pool.Initialize();
  
             mc =  new  MemcachedClient();
             mc.PoolName = memCachedConfigInfo.PoolName;
             mc.EnableCompression =  false ;
         }
  
         /// <summary>
         /// 缓存服务器地址列表
         /// </summary>
         public  static  string [] ServerList
         {
             set
             {
                 if  (value !=  null )
                     serverList = value;
             }
             get  {  return  serverList; }
         }
  
         /// <summary>
         /// 客户端缓存操作对象
         /// </summary>
         public  static  MemcachedClient CacheClient
         {
             get
             {
                 if  (mc ==  null )
                     CreateManager();
  
                 return  mc;
             }
         }
  
         public  static  void  Dispose()
         {
             if  (pool !=  null )
                 pool.Shutdown();
         }
  
     }
}

 

cache操作接口类ICacheStrategy.cs（为了方便扩展其他的cache）：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
using  System;
using  System.Text;
  
namespace  Plugin.Cache
{
     /// <summary>
     /// 公共缓存策略接口
     /// </summary>
     public  interface  ICacheStrategy
     {
         /// <summary>
         /// 添加指定ID的对象
         /// </summary>
         /// <param name="objId">缓存键</param>
         /// <param name="o">缓存对象</param>
         void  AddObject( string  objId,  object  o);
        
         /// <summary>
         /// 移除指定ID的对象
         /// </summary>
         /// <param name="objId">缓存键</param>
         void  RemoveObject( string  objId);
         /// <summary>
         /// 返回指定ID的对象
         /// </summary>
         /// <param name="objId">缓存键</param>
         /// <returns></returns>
         object  RetrieveObject( string  objId);
         /// <summary>
         /// 到期时间,单位：秒
         /// </summary>
         int  TimeOut {  set ; get ;}
    }
}

MemCached.cs类

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
using  System;
using  System.Web;
using  System.Collections;
using  System.Web.Caching;
  
namespace  Plugin.Cache
{
     /// <summary>
     /// 默认缓存管理类,默认用memcached
     /// </summary>
     public  class  MemCached : ICacheStrategy
     {   
         /// <summary>
         /// 设置到期相对时间[单位: 秒] 
         /// </summary>
         public  int  TimeOut {  set ;  get ; }
          
         /// <summary>
         /// 加入当前对象到缓存中
         /// </summary>
         /// <param name="objId">对象的键值</param>
         /// <param name="o">缓存的对象</param>
         public  virtual  void  AddObject( string  objId,  object  o)
         {
             if  (TimeOut > 0)
             {
                 MemCachedManager.CacheClient.Set(objId, o, System.DateTime.Now.AddSeconds(TimeOut));
             }
             else
             {
                 MemCachedManager.CacheClient.Set(objId, o);
             }
         }
  
         /// <summary>
         /// 删除缓存对象
         /// </summary>
         /// <param name="objId">对象的关键字</param>
         public  virtual  void  RemoveObject( string  objId)
         {
             if  (MemCachedManager.CacheClient.KeyExists(objId))
                 MemCachedManager.CacheClient.Delete(objId);
         }
  
  
         /// <summary>
         /// 返回一个指定的对象
         /// </summary>
         /// <param name="objId">对象的关键字</param>
         /// <returns>对象</returns>
         public  virtual  object  RetrieveObject( string  objId)
         {
             return  MemCachedManager.CacheClient.Get(objId);
         }
  
     }
}

 

实体类MemCachedConfigInfo.cs

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
using  Yintai.Plugin.Common;
  
/// <summary>
/// MemCached配置信息类文件
/// </summary>
  
namespace  Plugin
{
     public  class  MemCachedConfigInfo
     {
         private  string [] _serverList;
         /// <summary>
         /// 链接地址
         /// </summary>
         public  string [] ServerList
         {
             get  {  return  _serverList; }
             set  { _serverList = value; }
         }
  
         private  string  _poolName;
         /// <summary>
         /// 链接池名称
         /// </summary>
         public  string  PoolName
         {
             get  {  return  string .IsNullOrEmpty(_poolName) ?  "Yintai.Plugin.Cache.MemCached"  : _poolName; }
             set  { _poolName = value; }
         }
  
         private  int  _intConnections;
  
         /// <summary>
         /// 初始化链接数
         /// </summary>
         public  int  IntConnections
         {
             get  {  return  _intConnections > 0 ? _intConnections : 3; }
             set  { _intConnections = value; }
         }
  
         private  int  _minConnections;
  
         /// <summary>
         /// 最少链接数
         /// </summary>
         public  int  MinConnections
         {
             get  {  return  _minConnections > 0 ? _minConnections : 3; }
             set  { _minConnections = value; }
         }
  
         private  int  _maxConnections;
  
         /// <summary>
         /// 最大连接数
         /// </summary>
         public  int  MaxConnections
         {
             get  {  return  _maxConnections > 0 ? _maxConnections : 5; }
             set  { _maxConnections = value; }
         }
  
         private  int  _socketConnectTimeout;
  
         /// <summary>
         /// Socket链接超时时间
         /// </summary>
         public  int  SocketConnectTimeout
         {
             get  {  return  _socketConnectTimeout > 1000 ? _socketConnectTimeout : 1000; }
             set  { _socketConnectTimeout = value; }
         }
  
         private  int  _socketTimeout;
  
         /// <summary>
         /// socket超时时间
         /// </summary>
         public  int  SocketTimeout
         {
             get  {  return  _socketTimeout > 1000 ? _maintenanceSleep : 3000; }
             set  { _socketTimeout = value; }
         }
  
         private  int  _maintenanceSleep;
  
         /// <summary>
         /// 维护线程休息时间
         /// </summary>
         public  int  MaintenanceSleep
         {
             get  {  return  _maintenanceSleep > 0 ? _maintenanceSleep : 30; }
             set  { _maintenanceSleep = value; }
         }
  
         private  bool  _failOver;
  
         /// <summary>
         /// 链接失败后是否重启,详情参见http://baike.baidu.com/view/1084309.htm
         /// </summary>
         public  bool  FailOver
         {
             get  {  return  _failOver; }
             set  { _failOver = value; }
         }
  
         private  bool  _nagle;
  
         /// <summary>
         /// 是否用nagle算法启动socket
         /// </summary>
         public  bool  Nagle
         {
             get  {  return  _nagle; }
             set  { _nagle = value; }
         }
     }
}

 

实现代码完了，下面就是把配置文件memcached.config反序列化成实体方法

用MemCachedConfig.cs实现配置文件的载入和读取LoadConfig是载入配置，SetConfig是保存配置，GetConfig是获取配置，其中用了了序列化和反序列化

MemCachedConfig.cs文件如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
using  System;
using  System.Collections.Generic;
using  System.Drawing;
using  System.Drawing.Imaging;
using  System.Linq;
using  System.Text;
using  System.Web;
using  Plugin.Cache;
using  Plugin.Common;
  
  
namespace  Plugin
{
     public  class  MemCachedConfig
     {
         private  static  object  _lockHelper =  new  object ();
         private  static  MemCachedConfigInfo config =  null ;
  
         public  static  void  LoadConfig( string  configfilepath)
         {
             if  (config ==  null )
             {
                 lock  (_lockHelper)
                 {
                     if  (config ==  null )
                     {
                         config = (MemCachedConfigInfo)SerializationHelper.Load( typeof (MemCachedConfigInfo), configfilepath);
                     }
                 }
             }
         }
  
         /// <summary>
         /// 获取配置
         /// </summary>
         /// <param name="anConfig"></param>
         public  static  MemCachedConfigInfo GetConfig()
         {
             return  config;
         }
  
         #region 私有方法
         public  static  void  SetConfig(MemCachedConfigInfo verifyImageServiceInfoList,  string  configfilepath)
         {
             SerializationHelper.Save(verifyImageServiceInfoList, configfilepath);
         }
  
         #endregion
     }
}

SerializationHelper.cs代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
using  System;
using  System.IO;
using  System.Xml.Serialization;
using  System.Xml;
using  System.Collections.Generic;
using  System.Text;
  
namespace  Plugin.Common
{
     /// <summary>
     /// SerializationHelper 的摘要说明。
     /// </summary>
     public  class  SerializationHelper
     {
         private  SerializationHelper()
         {}
  
         private  static  Dictionary< int , XmlSerializer> serializer_dict =  new  Dictionary< int , XmlSerializer>();
  
         public  static  XmlSerializer GetSerializer(Type t)
         {
             int  type_hash = t.GetHashCode();
  
             if  (!serializer_dict.ContainsKey(type_hash))
                 serializer_dict.Add(type_hash,  new  XmlSerializer(t));
  
             return  serializer_dict[type_hash];
         }
  
  
         /// <summary>
         /// 反序列化
         /// </summary>
         /// <param name="type">对象类型</param>
         /// <param name="filename">文件路径</param>
         /// <returns></returns>
         public  static  object  Load(Type type,  string  filename)
         {
             FileStream fs =  null ;
             try
             {
                 // open the stream...
                 fs =  new  FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                 XmlSerializer serializer =  new  XmlSerializer(type);
                 return  serializer.Deserialize(fs);
             }
             catch (Exception ex)
             {
                 throw  ex;
             }
             finally
             {
                 if (fs !=  null )
                     fs.Close();
             }
         }
  
  
         /// <summary>
         /// 序列化
         /// </summary>
         /// <param name="obj">对象</param>
         /// <param name="filename">文件路径</param>
         public  static  bool  Save( object  obj,  string  filename)
         {
             bool  success =  false ;
  
             FileStream fs =  null ;
             // serialize it...
             try
             {
                 fs =  new  FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
                 XmlSerializer serializer =  new  XmlSerializer(obj.GetType());
                 serializer.Serialize(fs, obj);
                 success =  true ;
             }
             catch (Exception ex)
             {
                 throw  ex;
             }
             finally
             {
                 if (fs !=  null )
                     fs.Close();
             }
             return  success;
  
         }
  
         /// <summary>
         /// xml序列化成字符串
         /// </summary>
         /// <param name="obj">对象</param>
         /// <returns>xml字符串</returns>
         public  static  string  Serialize( object  obj)
         {
             string  returnStr =  "" ;
             XmlSerializer serializer = GetSerializer(obj.GetType());
             MemoryStream ms =  new  MemoryStream();
             XmlTextWriter xtw =  null ;
             StreamReader sr =  null ;
             try
             {
                 xtw =  new  System.Xml.XmlTextWriter(ms, Encoding.UTF8);
                 xtw.Formatting = System.Xml.Formatting.Indented;
                 serializer.Serialize(xtw, obj);
                 ms.Seek(0, SeekOrigin.Begin);
                 sr =  new  StreamReader(ms);
                 returnStr = sr.ReadToEnd();
             }
             catch  (Exception ex)
             {
                 throw  ex;
             }
             finally
             {
                 if  (xtw !=  null )
                     xtw.Close();
                 if  (sr !=  null )
                     sr.Close(); 
                 ms.Close();
             }
             return  returnStr;
  
         }
  
         public  static  object  DeSerialize(Type type,  string  s)
         { 
             byte [] b = System.Text.Encoding.UTF8.GetBytes(s);
             try
             {
                 XmlSerializer serializer = GetSerializer(type);
                 return  serializer.Deserialize( new  MemoryStream(b));
             }
             catch  (Exception ex)
             {
                 throw  ex;
             }
         }
     }
}

最后配置文件类似这样的：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?xml version= "1.0" ?>
<MemCachedConfigInfo xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"  xmlns:xsd= "http://www.w3.org/2001/XMLSchema" >
   <ServerList>
     < string >10.32.33.120:11211</ string >
   </ServerList>
   <PoolName>Plugin.Cache.MemCached</PoolName>
   <IntConnections>3</IntConnections>
   <MinConnections>3</MinConnections>
   <MaxConnections>5</MaxConnections>
   <SocketConnectTimeout>1000</SocketConnectTimeout>
   <SocketTimeout>30</SocketTimeout>
   <MaintenanceSleep>30</MaintenanceSleep>
   <FailOver> true </FailOver>
   <Nagle> false </Nagle>
</MemCachedConfigInfo>

 

使用时调用方法：

MemCachedConfig.LoadConfig(Server.MapPath("/config/memcached.config"));

这个方法通过LoadConfig把配置加载进来，反序列化成MemCachedConfigInfo实体并放入私有静态变量config 中，并通过GetConfig() 获取config，然后MemCachedManager类通过private static MemCachedConfigInfo memCachedConfigInfo = MemCachedConfig.GetConfig();方法获取到配置了。

文章来源：http://www.cnblogs.com/seesea125/archive/2012/07/16/2593486.html


原文(文章来源)：http://www.veryhuo.com/a/view/50515.html

Lionel Crazy
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值