缓存cache(擦车)
第一次接触到cache的时候,是在webform中,第一次接触,我就再也没能忘记,cache(擦车,的拼音)
客户端浏览器缓存
cdn缓存原理
阿里云cdn开启设置
有句话叫做,系统性能优化的第一步,就是使用缓存,所以,缓存真的很重要
缓存:
实际上是一种效果&目标,就是获取数据点时候,第一次获取之后找个地方存起来,后面直接用,这样一来可以提升后面每次获取数据的效率。读取配置文件的时候把信息放在静态字段,这个就是缓存。缓存是无处不在的。
我们来请求一个网站,打开开发人员工具
客户端缓存的好处:
1、缩短网络路径,加快响应速度
2、减少请求,降低服务器压力
浏览器缓存究竟是怎么做到的?
打开一个网页,浏览器-----请求---服务器---处理请求会发响应------浏览器展示
http协议,数据传输的格式(协议,就像是两人交流,都用什么语言)
信息是否缓存,一定是服务器控制的。responseheader--cache---control来指定下缓存策略,浏览器看到了这个,就去存储一下。
第一次请求服务器:
再一次请求服务器
dns是互联网的第一跳,dns缓存就是cdn,内容分发网络,cdn就是加速缓存的
没有用cdn的请求:
使用了cdn缓存
反向代理:
1、隔离网络,保护服务器(节约公共ip)
2、网络加速,反向代理双网卡
3、负载均衡
4、缓存(跟cdn,也是识别一下header,压缩到一个物理路径/内存)
为什么叫反向代理?因为他就是一个代理,一般的代理,是客户端和服务器之间,有一个代理,去做处理的。但是这个代理是安装在服务器端的。
几种缓存套路相同,但是位置不同,影响的范围也不同。
客户端缓存:只影响当前用户
cdn缓存:针对一批用户
反向代理缓存:针对全部用户。
客户端缓存,存在内存或者硬盘,下次直接用。cookie,存在内存或者硬盘,浏览器每次请求服务器都会带上的信息。
什么时候用缓存?
1、重复请求,100人访问首页,每个人其实做的都一样,不就是重复
2、耗时好资源
3、结果没变的
下面有一个第三方数据存储和获取的地方:
/// <summary> /// 第三方数据存储和获取的地方 /// </summary> public class customcache { /// <summary> /// private:私有一下数据容器,安全 /// static:不被gc /// 字典:读写效率高 /// </summary> private static dictionary<string, object> customcachedictionary = new dictionary<string, object>(); public static void add(string key, object ovaule) { customcachedictionary.add(key, ovaule); } /// <summary> /// 要求在get前做exists检测 /// </summary> /// <typeparam name="t"></typeparam> /// <param name="key"></param> /// <returns></returns> public static t get<t>(string key) { return (t)customcachedictionary[key]; } public static bool exists(string key) { return customcachedictionary.containskey(key); } public static t gett<t>(string key, func<t> func) { t t = default(t); if (!customcache.exists(key)) { t = func.invoke(); customcache.add(key, t); } else { t = customcache.get<t>(key); } return t; } }
存取数据的唯一标识:1 唯一的 2 能重现
for (int i = 0; i < 5; i++) { console.writeline($"获取{nameof(dbhelper)} {i}次 {datetime.now.tostring("yyyymmdd hhmmss.fff")}"); //list<program> programlist = dbhelper.query<program>(123); list<program> programlist = null; string key = $"{nameof(dbhelper)}_query_{123}"; //存取数据的唯一标识:1 唯一的 2 能重现 //if (!customcache.exists(key)) //{ // programlist = dbhelper.query<program>(123); // customcache.add(key, programlist); //} //else //{ // programlist = customcache.get<list<program>>(key); //} programlist = customcache.gett<list<program>>(key, () => dbhelper.query<program>(123)); }
/// <summary> /// 数据库查询 /// </summary> public class dbhelper { /// <summary> /// 1 耗时耗资源 /// 2 参数固定时,结果不变 /// </summary> /// <typeparam name="t"></typeparam> /// <param name="index"></param> /// <returns></returns> public static list<t> query<t>(int index) { console.writeline("this is {0} query", typeof(dbhelper)); long lresult = 0; for (int i = index; i < 1000000000; i++) { lresult += i; } list<t> tlist = new list<t>(); for (int i = 0; i < index % 3; i++) { tlist.add(default(t)); } return tlist; } }
缓存优化性能,核心就是结果重用,下次请求还是上一次的结果。如果数据库中有变化,岂不是用了一个错误的数据?是的,缓存是难免的,缓存难免会有脏数据,当然了,我们也会分门别类的去尽量减少脏数据。
用户--角色--菜单,用户权限查的多+比较耗资源+相对稳定,非常适合缓存,缓存方式应该是用户id为key,菜单列表作为value。
string name = "bingle"; list<string> menu = new list<string>(); if (!customcache.exists(name)) { menu = new list<string>() { "123", "125553", "143", "123456" }; customcache.add(name, menu); } else { menu = customcache.get<list<string>>(name); }
假如bingle的权限变化了,缓存应该失效。数据更新影响单挑缓存,常规做法是remove而不是更新,因为缓存只是用来提升效率的,而不是数据保存的,因此不需要更新,只需要删除就好,如果真的下次用上了,到时候再去初始化。
customcache类增加删除缓存的方法:
public static void remove(string key) { customcachedictionary.remove(key); }
string name = "bingle"; customcache.remove(name); list<string> menu = new list<string>(); if (!customcache.exists(name)) { menu = new list<string>() { "123", "125553", "143" }; customcache.add(name, menu); } else { menu = customcache.get<list<string>>(name); }
删除了某个菜单,影响了一大批用户。根据菜单--昭觉寺---找用户---每一个拼装key然后去remove(最准确)。但是这种方式不行,为了缓存增加数据库的任务,最大的问题是数据量的问题,缓存是二八原则,只有20%的热点用户才缓存,这样做的成本太高。
可以选择加上一个removeall的方法
public static void removeall() { customcachedictionary.clear(); }
或者,菜单删除了,能不能只影响一部分的缓存数据呢?
1、添加缓存时,key带上规则,比如权限包含_menu_
2、清理时,就只删除key含_menu_的
/// <summary> /// 按条件删除 /// </summary> /// <param name="func"></param> public static void removecondition(func<string, bool> func) { list<string> keylist = new list<string>(); lock (customcache_lock) foreach (var key in customcachedictionary.keys) { if (func.invoke(key)) { keylist.add(key); } } keylist.foreach(s => remove(s)); }
第三方修改了数据,缓存并不知道,这个就没办法了
a 可以调用接口清理缓存,b系统修改数据,调用c西永通知下缓存更新,b就只能容忍了,容忍脏数据,但是可以加上时间限制,减少影响时间。
时间,过期策略:
永久有效----目前就是
绝对过期:
有个时间点,超过就过期了
滑动过期:
多久之后过期,如果期间更新/查询/检查存在,就再次延长多久。
/// <summary> /// 主动清理 /// </summary> static customcache() { task.run(() => { while (true) { try { list<string> keylist = new list<string>(); lock (customcache_lock) { foreach (var key in customcachedictionary.keys) { datamodel model = (datamodel)customcachedictionary[key]; if (model.obslotetype != obslotetype.never && model.deadline < datetime.now) { keylist.add(key); } } keylist.foreach(s => remove(s)); } thread.sleep(1000 * 60 * 10); } catch (exception ex) { console.writeline(ex.message); continue; } } }); }
多线程问题:
list<task> tasklist = new list<task>(); for (int i = 0; i < 110000; i++) { int k = i; tasklist.add(task.run(() => customcache.add($"testkey_{k}", $"testvalue_{k}", 10))); } for (int i = 0; i < 100; i++) { int k = i; tasklist.add(task.run(() => customcache.remove($"testkey_{k}"))); } for (int i = 0; i < 100; i++) { int k = i; tasklist.add(task.run(() => customcache.exists($"testkey_{k}"))); } //thread.sleep(10*1000); task.waitall(tasklist.toarray());
多线程操作非现场安全的容器,会造成冲突
1、线程安全容器concurrentdictionary
2、用lock---add/remove/遍历,可以解决问题,但是性能呢?
怎么降低影响,提升性能呢?多个数据容器,多个锁,容器之间可以并发
为了解决多线程问题,customcache 类最终修改成如下:
public class customcache { //concurrentdictionary private static readonly object customcache_lock = new object(); /// <summary> /// 主动清理 /// </summary> static customcache() { task.run(() => { while (true) { try { list<string> keylist = new list<string>(); lock (customcache_lock) { foreach (var key in customcachedictionary.keys) { datamodel model = (datamodel)customcachedictionary[key]; if (model.obslotetype != obslotetype.never && model.deadline < datetime.now) { keylist.add(key); } } keylist.foreach(s => remove(s)); } thread.sleep(1000 * 60 * 10); } catch (exception ex) { console.writeline(ex.message); continue; } } }); } /// <summary> /// private:私有一下数据容器,安全 /// static:不被gc /// 字典:读写效率高 /// </summary> //private static dictionary<string, object> customcachedictionary = new dictionary<string, object>(); private static dictionary<string, object> customcachedictionary = new dictionary<string, object>(); public static void add(string key, object ovaule) { lock (customcache_lock) customcachedictionary.add(key, new datamodel() { value = ovaule, obslotetype = obslotetype.never, }); } /// <summary> /// 绝对过期 /// </summary> /// <param name="key"></param> /// <param name="ovaule"></param> /// <param name="timeoutsecond"></param> public static void add(string key, object ovaule, int timeoutsecond) { lock (customcache_lock) customcachedictionary.add(key, new datamodel() { value = ovaule, obslotetype = obslotetype.absolutely, deadline = datetime.now.addseconds(timeoutsecond) }); } /// <summary> /// 相对过期 /// </summary> /// <param name="key"></param> /// <param name="ovaule"></param> /// <param name="duration"></param> public static void add(string key, object ovaule, timespan duration) { lock (customcache_lock) customcachedictionary.add(key, new datamodel() { value = ovaule, obslotetype = obslotetype.relative, deadline = datetime.now.add(duration), duration = duration }); } /// <summary> /// 要求在get前做exists检测 /// </summary> /// <typeparam name="t"></typeparam> /// <param name="key"></param> /// <returns></returns> public static t get<t>(string key) { return (t)(((datamodel)customcachedictionary[key]).value); } /// <summary> /// 被动清理,请求了数据,才能清理 /// </summary> /// <param name="key"></param> /// <returns></returns> public static bool exists(string key) { if (customcachedictionary.containskey(key)) { datamodel model = (datamodel)customcachedictionary[key]; if (model.obslotetype == obslotetype.never) { return true; } else if (model.deadline < datetime.now)//现在已经超过你的最后时间 { lock (customcache_lock) customcachedictionary.remove(key); return false; } else { if (model.obslotetype == obslotetype.relative)//没有过期&是滑动 所以要更新 { model.deadline = datetime.now.add(model.duration); } return true; } } else { return false; } } /// <summary> /// 删除key /// </summary> /// <param name="key"></param> public static void remove(string key) { lock (customcache_lock) customcachedictionary.remove(key); } public static void removeall() { lock (customcache_lock) customcachedictionary.clear(); } /// <summary> /// 按条件删除 /// </summary> /// <param name="func"></param> public static void removecondition(func<string, bool> func) { list<string> keylist = new list<string>(); lock (customcache_lock) foreach (var key in customcachedictionary.keys) { if (func.invoke(key)) { keylist.add(key); } } keylist.foreach(s => remove(s)); } public static t gett<t>(string key, func<t> func) { t t = default(t); if (!customcache.exists(key)) { t = func.invoke(); customcache.add(key, t); } else { t = customcache.get<t>(key); } return t; } } /// <summary> /// 缓存的信息 /// </summary> internal class datamodel { public object value { get; set; } public obslotetype obslotetype { get; set; } public datetime deadline { get; set; } public timespan duration { get; set; } //数据清理后出发事件 public event action dataclearevent; } public enum obslotetype { never, absolutely, relative }
public class customcachenew { //动态初始化多个容器和多个锁 private static int cpunumer = 0;//获取系统的cpu数 private static list<dictionary<string, object>> dictionarylist = new list<dictionary<string, object>>(); private static list<object> locklist = new list<object>(); static customcachenew() { cpunumer = 4; for (int i = 0; i < cpunumer; i++) { dictionarylist.add(new dictionary<string, object>()); locklist.add(new object()); } task.run(() => { while (true) { thread.sleep(1000 * 60 * 10); try { for (int i = 0; i < cpunumer; i++) { list<string> keylist = new list<string>(); lock (locklist[i])//减少锁的影响范围 { foreach (var key in dictionarylist[i].keys) { datamodel model = (datamodel)dictionarylist[i][key]; if (model.obslotetype != obslotetype.never && model.deadline < datetime.now) { keylist.add(key); } } keylist.foreach(s => dictionarylist[i].remove(s)); } } } catch (exception ex) { console.writeline(ex.message); continue; } } }); }
缓存究竟哪里用?满足哪些特点适合用缓存?
1、访问频繁
2、耗时耗资源
3、相对稳定
4、体积不那么大的
不是说严格满足,具体的还要看情况,存一次能查三次,就值得缓存(大型想换标准)
下面应该用缓存
1、字典数据
2、省市区
3、配置文件
4、网站公告信息
5、部门权限,菜单权限
6、热搜
7、类别列表/产品列表
8、用户,其实session也是缓存的一种表现
股票信息价格/彩票开奖信息,这些不能用缓存,即时性要求很高。图片/视频,这些也不行,太大了。商品评论,这个可以用缓存的,虽然评论汇编,但是这个不重要,我们不一定非要看到最新的,而且第一页一般不变。
可以测试下customcache的性能,十万/百万/千万 插入/获取/删除的性能。