Memcached的应用

聊聊Memcached的应用

是一缓存，能够Set, Get value，哈哈，普通用法如下：

public User GetUser(int userId)
{
            UserInfo user = cacheService.Get("UserInfo:" + userId) as UserInfo;//cacheService是自定义的接口，具体的memcache实现代码被隔离了 if (user == null)
            {
                user = dao.GetUser(userId);
                cacheService.Set("UserInfo:" + userId, user);
            }
            return user;
}

在真正使用Memcached之前，需要先初始化它，如下：

string[] serverlist = { "192.168.1.11:11211", "192.168.1.12:11211", "192.168.1.13:11211" };//服务器可以是多个  

            //初始化池  
            SockIOPool pool = SockIOPool.GetInstance();
            pool.SetServers(serverlist);//设置连接池可用的cache服务器列表，server的构成形式是IP:PORT（如：127.0.0.1:11211）  
            pool.InitConnections = 3;//初始连接数  
            pool.MinConnections = 3;//最小连接数  
            pool.MaxConnections = 5;//最大连接数  
            pool.SocketConnectTimeout = 1000;//设置连接的套接字超时  
            pool.SocketTimeout = 3000;//设置套接字超时读取  
            pool.MaintenanceSleep = 30;//设置维护线程运行的睡眠时间。如果设置为0，那么维护线程将不会启动,30就是每隔30秒醒来一次  

            //获取或设置池的故障标志。  
            //如果这个标志被设置为true则socket连接失败，将试图从另一台服务器返回一个套接字如果存在的话。  
            //如果设置为false，则得到一个套接字如果存在的话。否则返回NULL，如果它无法连接到请求的服务器。  
            pool.Failover = true;

            pool.Nagle = false;//如果为false，对所有创建的套接字关闭Nagle的算法  
            pool.Initialize();

MemcachedProvider代码：

public class MemcachedProvider : ICache
    {
        private MemcachedClient mc = new MemcachedClient();
        public void Set(string key, object o)
        {
            mc.Set(key, o);
        }

        public object Get(string key)
        {
            return mc.Get(key);
        }
    }

 

用法很简单，下面说说它的一些限制：

• 每个key最多<=250长度
• 每个value最大<=1M（如果超过1M，则在C#端自己分解搞定）
• 没有冗余机制，既：当某一台memcached服务器down掉后，数据就丢失了，不会自动平衡数据

示例的UML图：

缓存的数据是通过hash后来分布到各台Memcache Server的，因此，假设每台Memcached Server都分别分配到4G内存的话，那我们的C#程序就能够用到12G内存。这个说法其实不准确，能否用足这12G的内存，完全看MemcacheClient端的分布key的算法（上图中左边接口部分），等以后再深入研究这个算法。

下面来说说当某台memcached server down掉后的解决办法（共3种解决方法）：

1. 用热备节点

2. 从配置文件里去掉那台失效的memcached server的ip

3. 增加一台Backup Memcached Server

 

一、用热备节点

程序端不改变任何东西

当发现某memcached server down机后，启动一台新memcached server，并且把新memcached server的IP修改为down机的IP（down掉的那台不要拿单独修复）

这个办法不利的地方是：在down掉和上线期间，缓存是没有的，会throw exception，需要程序捕获，并且当成null值来处理，会增加数据库的压力

 

二、从配置文件里去掉那台失效的memcached server的ip

那就是修改配置文件了，然后再把down掉的server慢慢修复，等修复后再修改配置文件...

非常不好，光修改配置文件就要导致application reset了。不过当资源有限时，也只能这样了。

 

三、增加一台Backup Memcached Server

物理节点图如下：

C#端：由原先的一个MemcachedClient客户端变成了"MemcachedClient"和"BackupMemcachedClient"共同存在

Memcached server服务器端：增加一台Backup Memcached Server,这台server性能和内存都要高于其他三台memcached server的配置，这台server将保存所有的cache，因此性能要求高，尤其是网络和内存。

先初始化这2个pool：

string[] serverlist = { "192.168.1.11:11211", "192.168.1.12:11211", "192.168.1.13:11211" };//普通Memcached服务器  

            //初始化池  
            SockIOPool pool = SockIOPool.GetInstance("NormalServers");                     //设置PoolName
            pool.SetServers(serverlist);//设置连接池可用的cache服务器列表，server的构成形式是IP:PORT（如：127.0.0.1:11211）  
            pool.InitConnections = 3;//初始连接数  
            pool.MinConnections = 3;//最小连接数  
            pool.MaxConnections = 5;//最大连接数  
            pool.SocketConnectTimeout = 1000;//设置连接的套接字超时  
            pool.SocketTimeout = 3000;//设置套接字超时读取  
            pool.MaintenanceSleep = 30;//设置维护线程运行的睡眠时间。如果设置为0，那么维护线程将不会启动,30就是每隔30秒醒来一次  

            //获取或设置池的故障标志。  
            //如果这个标志被设置为true则socket连接失败，将试图从另一台服务器返回一个套接字如果存在的话。  
            //如果设置为false，则得到一个套接字如果存在的话。否则返回NULL，如果它无法连接到请求的服务器。  
            pool.Failover = true;

            pool.Nagle = false;//如果为false，对所有创建的套接字关闭Nagle的算法  
            pool.Initialize();


            string[] backupServerlist = { "192.168.1.14:11211"};                         //Backup服务器 //初始化池  
            SockIOPool backupPool = SockIOPool.GetInstance("BackupServers");             //设置PoolName
            backupPool.SetServers(backupServerlist);//设置连接池可用的cache服务器列表，server的构成形式是IP:PORT（如：127.0.0.1:11211）  
            backupPool.InitConnections = 3;//初始连接数  
            backupPool.MinConnections = 3;//最小连接数  
            backupPool.MaxConnections = 5;//最大连接数  
            backupPool.SocketConnectTimeout = 1000;//设置连接的套接字超时  
            backupPool.SocketTimeout = 3000;//设置套接字超时读取  
            backupPool.MaintenanceSleep = 30;//设置维护线程运行的睡眠时间。如果设置为0，那么维护线程将不会启动,30就是每隔30秒醒来一次  

            //获取或设置池的故障标志。  
            //如果这个标志被设置为true则socket连接失败，将试图从另一台服务器返回一个套接字如果存在的话。  
            //如果设置为false，则得到一个套接字如果存在的话。否则返回NULL，如果它无法连接到请求的服务器。  
            backupPool.Failover = true;

            backupPool.Nagle = false;//如果为false，对所有创建的套接字关闭Nagle的算法  
            backupPool.Initialize();

 

 MemcachedProvider改为：

public class MemcachedProvider : ICache
    {
        private static MemcachedClient GetNormalServerClient()
        { 
            MemcachedClient mc = new MemcachedClient();
            mc.PoolName = "NormalServers";
            return mc;
        }
        private static MemcachedClient GetBackupServerClient()
        {
            MemcachedClient mc = new MemcachedClient();
            mc.PoolName = "BackupServers";
            return mc;
        }
        
        public void Set(string key, object o)
        {
            try
            {
                GetNormalServerClient().Set(key, o);
                GetBackupServerClient().Set(key, o);       //这个看情况改为异步执行
            }
            catch
            { 
                //notify or log
            }
        }

        public object Get(string key)
        {
            object o=null;
            try
            {
                o = GetNormalServerClient().Get(key);
            }
            catch
            {
                //notify or log
            }
            if (o != null)
                return o;

            try
            {
                o = GetBackupServerClient().Get(key);
            }
            catch
            {
                //notify or log
            }

            return o;
        }
    }

就这些吧。

 

自省推动进步，视野决定未来。
心怀远大理想。
为了家庭幸福而努力。

 

分类:  架构,  可扩展

标签:  Memcached

创建全局SystemTray.ProgressIndicator

 

当处理耗时任务时，我们自然要给个进度指示器让用户看到应用正在做事呢，不然用户就会想到底好没好啊，死了？。所以我们一定要有进度指示器，这样才是一个正常的用户体验。而创建进度指示器的最简单方法就是使用系统托盘里的ProgressIndicator，不过系统托盘和页面是挂钩的，要是用户这时转入其它页面，那ProgressIndicator就没了啊，用户就看不到进度了。所以不管用户做了什么事，ProgressIndicator都要显示出来，就是要做个全局的ProgressIndicator。于是网上搜索一番，找到了个代码，思路是这样的：写一个类，保存ProgressIndicator的相关数据，订阅Frame的Navigating和Navigated，监视页面切换。对移入的页面，利用保存的数据创建一个ProgressIndicator显示出来，对移出的页面，隐藏ProgressIndicator。不过后来想了想，能不能用绑定来实现呢？于是试了一下，果真可以。下面是相关代码：

using System;
using System.ComponentModel;
namespace *.ViewModels
{
    public class ProgressIndicatorViewModel : INotifyPropertyChanged
    {
        private Boolean isVisible;
        private String text;
        private Boolean isIndeterminate;
        private Double value;

        /// <summary>
        /// 获取或设置 是否显示ProgressIndicator。
        /// </summary>
        public Boolean IsVisible
        {
            get
            {
                return isVisible;
            }
            set
            {
                if (isVisible != value)
                {
                    isVisible = value;
                    NotifyPropertyChanged("IsVisible");
                }
            }
        }
        /// <summary>
        /// 获取或设置 显示的文字。
        /// </summary>
        public String Text
        {
            get
            {
                return text;
            }
            set
            {
                if (text != value)
                {
                    text = value;
                    NotifyPropertyChanged("Text");
                }
            }
        }
        /// <summary>
        /// 获取或设置 进度指示器是不确定的还是确定的。
        /// </summary>
        public Boolean IsIndeterminate
        {
            get
            {
                return isIndeterminate;
            }
            set
            {
                if (isIndeterminate != value)
                {
                    isIndeterminate = value;
                    NotifyPropertyChanged("IsIndeterminate");
                }
            }
        }
        /// <summary>
        /// 获取或设置 进度（0-1）。
        /// </summary>
        public Double Value
        {
            get
            {
                return value;
            }
            set
            {
                if (this.value != value)
                {
                    this.value = value;
                    NotifyPropertyChanged("Value");
                }
            }
        }

        public ProgressIndicatorViewModel()
        {
            isVisible = false;
            text = String.Empty;
            isIndeterminate = false;
            value = 0;
        }

        public event PropertyChangedEventHandler PropertyChanged;
        private void NotifyPropertyChanged(String propertyName)
        {
            if (null != PropertyChanged)
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

<phone:PhoneApplicationPage
    shell:SystemTray.Opacity="0"
    shell:SystemTray.IsVisible="{Binding IsVisible}">
    
    <shell:SystemTray.ProgressIndicator>
        <shell:ProgressIndicator IsVisible="{Binding IsVisible}"
                                 Text="{Binding Text}"
                                 IsIndeterminate="{Binding IsIndeterminate}"
                                 Value="{Binding Value}"/>
    </shell:SystemTray.ProgressIndicator>

    <Grid>
    </Grid>

</phone:PhoneApplicationPage>

 

 

 

 

分类:  我来说技术之WP