出处:http://www.codeceo.com/article/cache-01.html
------------------------------------------------------------------------------
介绍
本篇主要说下楼主平常项目中缓存使用经验和遇到过的问题。
目录
一: 基本写法
二:缓存雪崩
1:全局锁,实例锁
2:字符串锁
三:缓存穿透
四:再谈缓存雪崩
五:总结
一:基本写法
为了方便演示,我们用Runtime.Cache做缓存容器,并定义个简单操作类。如下:
public class CacheHelper { public static object Get(string cacheKey) { return HttpRuntime.Cache[cacheKey]; } public static void Add(string cacheKey, object obj, int cacheMinute) { HttpRuntime.Cache.Insert(cacheKey, obj, null, DateTime.Now.AddMinutes(cacheMinute), Cache.NoSlidingExpiration, CacheItemPriority.Normal, null); } }
简单读取:
public object GetMemberSigninDays1() { const int cacheTime = 5; const string cacheKey = "mushroomsir"; var cacheValue = CacheHelper.Get(cacheKey); if (cacheValue != null) return cacheValue; cacheValue = "395"; //这里一般是 sql查询数据。 例:395 签到天数 CacheHelper.Add(cacheKey, cacheValue, cacheTime); return cacheValue; }
在项目中,有不少这样写法。这样写没有错,但在并发量上来后就会有问题。继续看
二:缓存雪崩
缓存雪崩是由于缓存失效(过期),新缓存未到期间。
这个中间时间内,所有请求都去查询数据库,而对数据库CPU和内存造成巨大压力,前端连接数不够、查询阻塞。
这个中间时间并没有那么短,比如sql查询1秒,加上传输解析0.5秒。 就是说1.5秒内所有用户查询,都是直接查询数据库的。
这种情况下,我们想到最多的就是加锁排队了。
1:全局锁,实例锁
public static object obj1 = new object(); public object GetMemberSigninDays2() { const int cacheTime = 5; const string cacheKey = "mushroomsir"; var cacheValue = CacheHelper.Get(cacheKey); if (cacheValue != null) return cacheValue; //lock (obj1) //全局锁 //{ // cacheValue = CacheHelper.Get(cacheKey); // if (cacheValue != null) // return cacheValue; // cacheValue = "395"; //这里一般是 sql查询数据。 例:395 签到天数 // CacheHelper.Add(cacheKey, cacheValue, cacheTime); //} lock (this) { cacheValue = CacheHelper.Get(cacheKey); if (cacheValue != null) return cacheValue; cacheValue = "395"; //这里一般是 sql查询数据。 例:395 签到天数 CacheHelper.Add(cacheKey, cacheValue, cacheTime); } return cacheValue; }
第一种:lock (obj1) 是全局锁可以满足,但我们要为每个函数都声明一个obj,不然在A、B函数都锁obj1时,必然会让其中一个阻塞。
第二种:lock (this) 这个锁当前实例,对其他实例无效,这个锁就没什么效果了。使用单例模式的可以锁。
但在当前实例中:A函数锁当前实例,其他锁当前实例的函数读写,也被阻塞。 不可取
2:字符串锁
既然锁对象不行,利用字符串的特性,我们直接锁缓存key呢。来看下
public object GetMemberSigninDays3() { const int cacheTime = 5; const string cacheKey = "mushroomsir"; var cacheValue = CacheHelper.Get(cacheKey); if (cacheValue != null) return cacheValue; const string lockKey = cacheKey + "n(*≧▽≦*)n"; //lock (cacheKey) //{ // cacheValue = CacheHelper.Get(cacheKey); // if (cacheValue != null) // return cacheValue; // cacheValue = "395"; //这里一般是 sql查询数据。 例:395 签到天数 // CacheHelper.Add(cacheKey, cacheValue, cacheTime); //} lock (lockKey) { cacheValue = CacheHelper.Get(cacheKey); if (cacheValue != null) return cacheValue; cacheValue = "395"; //这里一般是 sql查询数据。 例:395 签到天数 CacheHelper.Add(cacheKey, cacheValue, cacheTime); } return cacheValue; }
第一种:lock (cacheName) 有问题,因为字符串也是共享的,会阻塞其他使用这个字符串的操作行为。 具体请看之前的博文 c#语言-多线程中的锁系统(一)。
2015-01-04 13:36更新:因为字符串被公共语言运行库 (CLR)暂留,这意味着整个程序中任何给定字符串都只有一个实例。所以才会用第二种
第二种:lock (lockKey) 可以满足。其实目就是为了保证锁的粒度最小并且全局唯一性,只锁当前缓存的查询行为。
三:缓存穿透
举个简单例子:一般我们会缓存用户搜索结果。而数据库查询不到,是不会做缓存的。但如果频繁查这个关键字,就会每次都直查数据库了。
这样缓存就没意义了,这也是常提的缓存命中率问题。
public object GetMemberSigninDays4() { const int cacheTime = 5; const string cacheKey = "mushroomsir"; var cacheValue = CacheHelper.Get(cacheKey); if (cacheValue != null) return cacheValue; const string lockKey = cacheKey + "n(*≧▽≦*)n"; lock (lockKey) { cacheValue = CacheHelper.Get(cacheKey); if (cacheValue != null) return cacheValue; cacheValue = null; //数据库查询不到,为空。 //if (cacheValue2 == null) //{ // return null; //一般为空,不做缓存 //} if (cacheValue == null) { cacheValue = string.Empty; //如果发现为空,我设置个默认值,也缓存起来。 } CacheHelper.Add(cacheKey, cacheValue, cacheTime); } return cacheValue; }
例子中我们把查询不到的结果,也给缓存起来了。这样就可以避免,查询为空时,引起缓存穿透了。
当然我们也可以单独设置个缓存区,进行第一层控制校验。 以便和正常缓存区分开了。
四:再谈缓存雪崩
额 不是用加锁排队方式就解决了吗?其实加锁排队只是为了减轻DB压力,并没有提高系统吞吐量。
在高并发下: 缓存重建期间,你是锁着的,1000个请求999个都在阻塞的。 用户体验不好,还浪费资源:阻塞的线程本可以处理后续请求的。
public object GetMemberSigninDays5() { const int cacheTime = 5; const string cacheKey = "mushroomsir"; //缓存标记。 const string cacheSign = cacheKey + "_Sign"; var sign = CacheHelper.Get(cacheSign); //获取缓存值 var cacheValue = CacheHelper.Get(cacheKey); if (sign != null) return cacheValue; //未过期,直接返回。 lock (cacheSign) { sign = CacheHelper.Get(cacheSign); if (sign != null) return cacheValue; CacheHelper.Add(cacheSign, "1", cacheTime); ThreadPool.QueueUserWorkItem((arg) => { cacheValue = "395"; //这里一般是 sql查询数据。 例:395 签到天数 CacheHelper.Add(cacheKey, cacheValue, cacheTime*2); //日期设缓存时间的2倍,用于脏读。 }); } return cacheValue; }
代码中,我们多用个缓存标记key,双检锁校验。它设置为正常时间,过期后通知另外的线程去更新缓存数据。
而实际的缓存由于设置了2倍的时间,仍然可以能用脏数据给前端展现。
这样就能提高不少系统吞吐量了。
五:总结
补充下: 这里说的阻塞其他函数指的是,高并发下锁同一对象。
实际使用中,缓存层封装往往要复杂的多。 关于更新缓存,可以单开一个线程去专门跑这些,图方便就扔线程池吧。
具体使用场景,可根据实际用户量来平衡。
--------------------------------------------------------------------------------------------------------
上次主要讨论缓存读写这块各种代码实现。本篇是就上次的问题接着来,继续看那些年我们各种缓存用法。
一:缓存预热
上次有同学问过。在第一次加载时,我们的缓存都为空,怎么进行预热。
单机Web情况下,一般我们使用RunTimeCache。相对于这种情况下:
1:我们可以在启动事件里面刷新
void Application_Start(object sender, EventArgs e) { //刷新 }
2:单写个刷新缓存页面,上线后手动刷新下、或发布时自动调用刷新、或干脆由用户自行触发。
分布式缓存(Redis、memcached)情况下:
比如:在几十台服务器缓存时,单刷满缓存都需要不少一段时间。
这种预热就复杂一些,有的会单写个应用程序去跑,也有的会单写套框架机制去处理(更智能化)。
目的都是在上线之前:所有的缓存都预先加载完毕。
二:多级缓存
2.1 介绍
我们晓得在CPU和内存之间一般都配有一级缓存、二级缓存来增加交换速度。
这样当CPU调用大量数据时,就可避开内存直接从CPU缓存中调用,加快读取速度。
根据CPU缓存得出多级缓存的特点:
1:每一级缓存中储存的是下一级缓存的一部分。
2:读取速度按级别依次递减,成本也依次递减,容量依次递增。
3:当前级别未命中时,才会去下一级寻找。
而在企业应用级开发中,使用多级缓存是同样的目的及设计,只是粒度更粗,更灵活。
根据速度依次排列lv1-lv6的缓存类型图:
3级缓存的命中流程图例子:
2.2 线程缓存
Web应用是天生的多线程开发。对于一些公共资源我们必须考虑线程安全,为止我们不得不通过锁来保证数据的完整性和正确性。
在实际当中,一台web服务器至少也得处理成百上千的请求。想一想,在业务复杂的处理流程,函数每调用一次我们都得锁一下。
对服务器也是个不小的浪费。而通过线程缓存,可以让当前处理用户请求的线程只拿自己需要的。
public static ThreadLocal<UserScore> localUserInfo = new ThreadLocal<UserScore>();
借助Net提供的线程本地变量,我们可以在请求入口去拉取当前用户的数据。
在之后线程整个生命周期里面,我们的业务逻辑可以毫无顾虑的使用这些数据,不需要考虑线程安全。
而且我们不用重新拿新数据,所以也不用担心数据撕裂的问题。
因为当前线程周期里面的数据是完整无误的,而只有用户第二次发起请求才会重新去拿新数据。
这样就能提高不少我们服务器吞吐量。注意要在线程出口销毁数据。
2.3 内存缓存
无论是远程数据库读取,还是缓存服务器读取。避免不了要跨进程,跨网络通信,有的还跨机房。
而应用程序频繁读写,对Web、DB服务器都是个不小的消耗,速度相较内存也慢的多。
代码上加锁、异步,甚至加服务器在内,都不是一个很好的办法。因为加载速度,对用户体验非常重要。
所以在有要求的项目中使用本地内存做二级缓存,是非常有必要的。目的就是1:抗并发,2:加快读取速度。
有个著名的缓存五分钟法则法则,就是说如果一个数据频繁被访问,那么就应该放内存中。
举个例子: 有100并发过来,加锁会导致前端99线程等候,这个99线程等候着,其实是一直在消耗Web服务器资源。不加就是缓存雪崩。
如果我们每分钟拉取一份缓存,缓存到内存,这样99线程等候时间极大缩短。
2.4 文件缓存
相对于内存,硬盘容量大,速度相较于走网络还更快。
所以我们完全可以把一些不经常变更,放在内存又比较浪费的数据缓存到本地硬盘。
比如使用sqlite一些文件数据库,我们很容易做到。
2.5 分布式缓存
基于内存缓存的redis、memcached等。
基于文件nosql的Casssandra、mongodb等。
redis、memcached是主流的分布式内存缓存,也是应用和DB中间最大的缓存层。
nosql这类的其实不单单只是做缓存用了,完全用在一些非核心业务的DB层了。
2.6 DB缓存
这一层DB主要是缓存由原始数据计算出的结果。而避免由Web程序通过SQL或在使用中直接计算。
当然我们也可以把计算好的数据,存储到redis做缓存。
三:多层缓存
多层缓存概念在很多地方都用到过:
1:上面我们说的多级缓存就是一种,把内容根据读取频率等级,分不同的层次存储,频率越高就越近。
2:还一种多层是缓存索引的做法,类B树查找,这样能提高检索效率。
3:从架构上来说客户端缓存,CDN缓存,反向代理缓存,服务端缓存,也是多层缓存。
四:总结
在使用上,大家根据实际场景,进行各种组合搭配。本篇谈的比较理论些,很多内容细节没展开。
比如分布式缓存使用,缓存置换策略及算法,缓存过期机制等。后面楼主会继续补充下去。
--------------------------------------------------------------------------------------------------
上次我们说了多级缓存,本章详细介绍下内存缓存该如何设计。
一:分析设计
假设有个项目有一定并发量,要用到多级缓存,如下:
在实际设计一个内存缓存前,我们需要考虑的问题:
1:内存与Redis的数据置换,尽可能在内存中提高数据命中率,减少下一级的压力。
2:内存容量的限制,需要控制缓存数量。
3:热点数据更新不同,需要可配置单个key过期时间。
4:良好的缓存过期删除策略。
5:缓存数据结构的复杂度尽可能的低。
关于置换及命中率:我们采用LRU算法,因为它实现简单,缓存key命中率也很好。
LRU即是:把最近最少访问的数据给淘汰掉,经常被访问到即是热点数据。
关于LRU数据结构:因为key优先级提升和key淘汰,所以需要顺序结构。我看到大多实现,都采用链表结构、
即:新数据插入到链表头部、被命中时的数据移动到头部。 添加复杂度O(1) 移动和获取复杂度O(N)。
有没复杂度更低的呢? 有Dictionary,复杂度为O(1),性能最好。 那如何保证缓存的优先级提升呢?
二:O(1)LRU实现
我们定义个LRUCache<TValue>类,构造参数maxKeySize 来控制缓存最大数量。
使用ConcurrentDictionary来作为我们的缓存容器,并能保证线程安全。
public class LRUCache<TValue> : IEnumerable<KeyValuePair<string, TValue>> { private long ageToDiscard = 0; //淘汰的年龄起点 private long currentAge = 0; //当前缓存最新年龄 private int maxSize = 0; //缓存最大容量 private readonly ConcurrentDictionary<string, TrackValue> cache; public LRUCache(int maxKeySize) { cache = new ConcurrentDictionary<string, TrackValue>(); maxSize = maxKeySize; } }
上面定义了 ageToDiscard、currentAge 这2个自增值参数,作用是:标记缓存列表中各个key的新旧程度。
核心实现步骤如下:
1:每次添加key时,currentAge自增并将currentAge值分配给这个缓存值的Age,currentAge始终增加。
public void Add(string key, TValue value) { Adjust(key); var result = new TrackValue(this, value); cache.AddOrUpdate(key, result, (k, o) => result); } public class TrackValue { public readonly TValue Value; public long Age; public TrackValue(LRUCache<TValue> lv, TValue tv) { Age = Interlocked.Increment(ref lv.currentAge); Value = tv; } }
2:在添加时,如超过最大数量。检查字典里是否有ageToDiscard年龄的key,如没有循环自增检查,有则删除、添加成功。
ageToDiscard+maxSize= currentAge ,这样设计就能在O(1)下保证可以淘汰旧数据,而不是使用链表移动。
public void Adjust(string key) { while (cache.Count >= maxSize) { long ageToDelete = Interlocked.Increment(ref ageToDiscard); var toDiscard = cache.FirstOrDefault(p => p.Value.Age == ageToDelete); if (toDiscard.Key == null) continue; TrackValue old; cache.TryRemove(toDiscard.Key, out old); } }
过期删除策略
大多数情况下,LRU算法对热点数据命中率是很高的。 但如果突然大量偶发性的数据访问,会让内存中存放大量冷数据,也就是缓存污染。
会引起LRU无法命中热点数据,导致缓存系统命中率急剧下降。也可以使用LRU-K、2Q、MQ等变种算法来提高命中率。
过期配置
1:我们通过设定、最大过期时间来尽量避免冷数据常驻内存。
2:大多数情况每个缓存的时间要求不一致的,所以在增加单个key的过期时间。
private TimeSpan maxTime; public LRUCache(int maxKeySize,TimeSpan maxExpireTime){} //TrackValue增加创建时间和过期时间 public readonly DateTime CreateTime; public readonly TimeSpan ExpireTime;
删除策略
1:关于key过期删除,最好使用定时删除了。 这样可以最快释放被占用的内存,但很明显,大量的定时器对CPU吃不消的。
2:所以我们采用惰性删除、在获取key的时检查是否过期,过期直接删除。
public Tuple<TrackValue, bool> CheckExpire(string key) { TrackValue result; if (cache.TryGetValue(key, out result)) { var age = DateTime.Now.Subtract(result.CreateTime); if (age >= maxTime || age >= result.ExpireTime) { TrackValue old; cache.TryRemove(key, out old); return Tuple.Create(default(TrackValue), false); } } return Tuple.Create(result, true); }
3:惰性删除虽然性能最好,对于冷数据来说,还是没解决缓存污染问题。 所以我们还需定期清理。
比如:开个线程,5分钟去遍历检查key一次。这个策略根据实际场景可配置。
public void Inspection() { foreach (var item in this) { CheckExpire(item.Key); } }
惰性删除+定期删除基本能满足我们需求了。
总结
如果继续完善下去,就是内存数据库的雏形,类似redis。
比如:增加删除key的通知,增加更多数据类型。 本篇也是参考了redis、Orleans的实现。