中小型网站的缓存策略

在上一篇文章《大型网站系统架构分析》中，介绍了大型网站的系统架构，其中缓存环境非常重要，大型网站往往使用Squid前端缓存服务器群，memcache分布式缓存，负载均衡，CDN等来提升性能。但中小型网站使用这些大家伙就有杀鸡用牛刀的感觉，但毋庸置疑，缓存是需要的，开发者开发程序的时候若没有并发思维，一味注重业务逻辑，往往导致并发用户可能在差不多相同的时间请求相同的数据，网站再请求数据库，如果使用缓存，对这种相同的请求，或者不变的数据，可以缓存起来，直接从内存读取，可以大大提升并发访问的性能，减少数据库访问次数。因为数据库往往是最容易出现瓶颈的地方，而通过使用恰当的缓存技术可以非常有效地减轻数据库的负载。

根据我的经验，中小型网站可以采用这样的缓存策略：

如果是单台服务器可以直接缓存在内存，怕内存不够就合理利用ASP.NET所提供的缓存机制，有现成的干嘛不用呢？缓存存在XML文件中也是一种备选方案，但首先速度没有内存的来的快，其次是写入并发写入XML的时候会锁住文件。可以选用现成的微软Cache application block来实现。
有多台的服务器的话可以考虑memcached，或者其他类似的东西，或者另加一个数据库作为缓存库也行啊。当然有钱的可以用内存数据库。

但不是所有数据都可以缓存的：

对于恒定不变的数据，系统启动后放入缓存就不过期不更新了。
对于偶尔改变的数据，缓存过期时间可以稍微长一些，比如15分钟。
对于经常改变的数据，但访问量极大的热点数据，可以缓存很短的时间，例如30秒，或60秒。（微软有一种数据库数据改变自动同步缓存的SqlDependency功能，有兴趣的读者可以关注）

如此，便可最大程度的利用缓存，从而可以有效提高系统性能，并明显减轻数据库和网络负载。

你也可以统计并发访问最高的页面和DB访问的频率，把网页静态化，或缓存该些热点，淘汰不热的(缓存替换算法)，即使缓存30秒，或60秒也是很大的性能提升，因为他们的并发访问量很大，导致数据库的压力也很大。

代码参考：使用策略模式和单例模式的单机内存缓存：(可以扩展到其他的缓存策略，例如memcache等)

ICacheStrategy.cs

using System;
using System.Text;
  
namespace Sample.Caching
{
/// <summary>
/// 缓存策略接口
/// </summary>
public interface ICacheStrategy
{
void AddObject(string objId, object o);

void AddObjectWithTimeout(string objId, object o, int timeoutSec);

void AddObjectWithFileChange(string objId, object o, string[] files);

void AddObjectWithDepend(string objId, object o, string[] dependKey);
  
void RemoveObject(string objId);
  
object RetrieveObject(string objId);
  
int TimeOut { set;get;}
}
}

DefaultCacheStrategy.cs

using System;
using System.Web;
using System.Collections;
using System.Web.Caching;
  
namespace Sample.Caching
{
/// <summary>
/// 默认的缓存策略，实现了缓存策略接口
/// </summary>
public class DefaultCacheStrategy : ICacheStrategy
{
private static readonly DefaultCacheStrategy instance = new DefaultCacheStrategy();
  
protected static volatile System.Web.Caching.Cache webCache = System.Web.HttpRuntime.Cache;
  
protected int _timeOut = 1; //默认缓存一分钟，也可以单独设置对象的超时时间
  
private static object syncObj = new object();
  
/// <summary>
/// Initializes the <see cref="DefaultCacheStrategy"/> class.
/// </summary>
static DefaultCacheStrategy()
{
//lock (syncObj)
//{
// //System.Web.HttpContext context = System.Web.HttpContext.Current;
// //if(context != null)
// // webCache = context.Cache;
// //else
// webCache = System.Web.HttpRuntime.Cache;
//} 
}
  
  
public int TimeOut
{
set { _timeOut = value > 0 ? value : 6000; }
get { return _timeOut > 0 ? _timeOut : 6000; }
}
  

public static System.Web.Caching.Cache GetWebCacheObj
{
get { return webCache; }
}
  
public void AddObject(string objId, object o)
{
  
if (objId == null || objId.Length == 0 || o == null)
{
return;
}
  
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
  
if (TimeOut == 6000)
{
webCache.Insert(objId, o, null, DateTime.MaxValue, TimeSpan.Zero, System.Web.Caching.CacheItemPriority.High, callBack);
}
else
{
webCache.Insert(objId, o, null, DateTime.Now.AddMinutes(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack);
}
}
  
public void AddObjectWith(string objId, object o)
{
if (objId == null || objId.Length == 0 || o == null)
{
return;
}
  
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
  
webCache.Insert(objId, o, null, System.DateTime.Now.AddHours(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack);
}
  

public void AddObjectWithTimeout(string objId, object o, int timeoutSec)
{
if (objId == null || objId.Length == 0 || o == null || timeoutSec <= 0)
{
return;
}
  
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
  
webCache.Insert(objId, o, null, System.DateTime.Now.AddSeconds(timeoutSec), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack);
}
  
public void AddObjectWithFileChange(string objId, object o, string[] files)
{
if (objId == null || objId.Length == 0 || o == null)
{
return;
}
  
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
  
CacheDependency dep = new CacheDependency(files, DateTime.Now);
  
webCache.Insert(objId, o, dep, System.DateTime.Now.AddHours(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack);
}
  

public void AddObjectWithDepend(string objId, object o, string[] dependKey)
{
if (objId == null || objId.Length == 0 || o == null)
{
return;
}
  
CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
  
CacheDependency dep = new CacheDependency(null, dependKey, DateTime.Now);
  
webCache.Insert(objId, o, dep, System.DateTime.Now.AddMinutes(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack);
}
  
public void onRemove(string key, object val, CacheItemRemovedReason reason)
{
switch (reason)
{
case CacheItemRemovedReason.DependencyChanged:
break;
case CacheItemRemovedReason.Expired:
{
//CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(this.onRemove);
  
//webCache.Insert(key, val, null, System.DateTime.Now.AddMinutes(TimeOut),
// System.Web.Caching.Cache.NoSlidingExpiration,
// System.Web.Caching.CacheItemPriority.High,
// callBack);
break;
}
case CacheItemRemovedReason.Removed:
{
break;
}
case CacheItemRemovedReason.Underused:
{
break;
}
default: break;
}
  
//TODO: write log here
}
  

public void RemoveObject(string objId)
{
//objectTable.Remove(objId);
if (objId == null || objId.Length == 0)
{
return;
}
webCache.Remove(objId);
}
  
  
public object RetrieveObject(string objId)
{
//return objectTable[objId];
  
if (objId == null || objId.Length == 0)
{
return null;
}
  
return webCache.Get(objId);
}
  
}
}

CachingManager.cs

using System;
using System.Collections.Generic;
using System.Text;
  
namespace Sample.Caching
{
/// <summary>
/// The caching manager
/// </summary>
public class CachingManager
{
private static ICacheStrategy cs;
private static volatile CachingManager instance = null;
private static object lockHelper = new object();

//private static System.Timers.Timer cacheConfigTimer = new System.Timers.Timer(15000);//Interval in ms
  

private CachingManager()
{
cs = new DefaultCacheStrategy();
  
////Set timer
//cacheConfigTimer.AutoReset = true;
//cacheConfigTimer.Enabled = true;
//cacheConfigTimer.Elapsed += new System.Timers.ElapsedEventHandler(Timer_Elapsed);
//cacheConfigTimer.Start();
}
  

private static void Timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
//TODO:
}
  

public static CachingManager GetCachingService()
{
if (instance == null)
{
lock (lockHelper)
{
if (instance == null)
{
instance = new CachingManager();
}
}
}
  
return instance;
}
  

public virtual void AddObject(string key, object o)
{
if (String.IsNullOrEmpty(key) || o == null) return;
  
lock (lockHelper)
{
if (cs.TimeOut <= 0) return;
  
cs.AddObject(key, o);
}
}
  

public virtual void AddObject(string key, object o, int timeout)
{
if (String.IsNullOrEmpty(key) || o == null) return;
  
lock (lockHelper)
{
if (cs.TimeOut <= 0) return;
  
cs.AddObjectWithTimeout(key, o, timeout);
}
}
  

public virtual object RetrieveObject(string objectId)
{
return cs.RetrieveObject(objectId);
}
  

public virtual void RemoveObject(string key)
{
lock (lockHelper)
{
cs.RemoveObject(key);
}
}
  

public void LoadCacheStrategy(ICacheStrategy ics)
{
lock (lockHelper)
{
cs = ics;
}
}
  

public void LoadDefaultCacheStrategy()
{
lock (lockHelper)
{
cs = new DefaultCacheStrategy();
}
}
}
}

调用：

CachingManager cm = CachingManager.GetCachingService();
cm.LoadDefaultCacheStrategy();
//从缓存获取
IList list = cm.RetrieveObject("mykey") as IList;
if (list == null)
{
list = DAL.GetData(); //从数据库查询
cm.AddObject("mykey", list, 2 * 60); //缓存2分钟
}
return list;

调用时序图：

posted on 2009-05-05 13:32 Mainz 阅读(2849) 评论(2) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

{var x NullPointerException}

中小型网站的缓存策略

导航

公告