中小型网站的缓存策略-白红宇

中小型网站的缓存策略

阅读量：6849 次

发布时间：2019-06-26

本文共 8883 字，大约阅读时间需要 29 分钟。

在上一篇文章《大型网站系统架构分析》中，介绍了大型网站的系统架构，其中缓存环境非常重要，大型网站往往使用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
{
/// 
/// 缓存策略接口
/// 
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
{
/// 
/// 默认的缓存策略，实现了缓存策略接口
/// 
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();
 
/// 
/// Initializes the 
 class.
/// 
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
{
/// 
/// The caching manager
/// 
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;

调用时序图：

转载地址：http://wloul.baihongyu.com/

你可能感兴趣的文章