标签：cpu dict 更新 结果 任务 data 针对 jin 缓存优化
第一次接触到Cache的时候，是在WebForm中，第一次接触，我就再也没能忘记，cache（擦车，的拼音）
客户端浏览器缓存https://blog.csdn.net/y874961524/article/details/61419716
CDN缓存原理https://www.cnblogs.com/shijingxiang/articles/5179032.html
阿里云CDN开启设置https://jingyan.baidu.com/article/948f5924f1d642d80ff5f980.html
有句话叫做，系统性能优化的第一步，就是使用缓存，所以，缓存真的很重要
缓存：
实际上是一种效果&目标，就是获取数据点时候，第一次获取之后找个地方存起来，后面直接用，这样一来可以提升后面每次获取数据的效率。读取配置文件的时候把信息放在静态字段，这个就是缓存。缓存是无处不在的。
我们来请求一个网站，打开开发人员工具
客户端缓存的好处：
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的性能，十万/百万/千万 插入/获取/删除的性能。
标签：cpu dict 更新 结果 任务 data 针对 jin 缓存优化
原文地址：https://www.cnblogs.com/taotaozhuanyong/p/11565162.html
