.Net 数据缓存浅析

目录

1场景出发

1.1数据请求

1.2优化改进

2缓存

3缓存进阶

3.1缓存清除

3.2有效性

3.3线程安全

4适用场景和优劣

4.1适用场景

4.2优劣

5结语

1场景出发

1.1数据请求

小吴开发了一个购物网站,其中涉及到这样一个环节:访客用户请求页面时,会请求数据库获取商品分类信息,然后返回该数据,展示商品的分类

对于这个环节,他是这样处理的

 /// <summary>
     /// 模拟数据库获取数据耗时操作
     /// </summary>
     public class DataSource
     {
         /// <summary>
         /// 获取商品分类
         /// </summary>
         /// <returns></returns>
         public static string GetCategories()
         {
             Thread.Sleep();//模拟耗时
             return "There are categories";
         }
     }

DataSource

    class Program
     {

         static void Main(string[] args)
         {
             string cats = DataSource.GetCategories();

             Console.WriteLine(cats);

             Console.ReadKey();
         }
     }

GetData

在初阶阶段,访客用户数量比较少,网站能够很好的运营

1.2优化改进

随着访客用户数量的增加,服务器压力越来越大,不少用户开始向客服抱怨,网页响应速度太慢

小吴不得不开始优化系统,他考虑到商品分类信息请求次数很多,但每次却是请求相同的数据,于是他决定把这部分数据放在常驻内存的静态变量中,然后在数据库直接获取数据上再加一层,来提供数据服务,改进如下:

  /// <summary>
     /// 模拟数据库获取数据耗时操作
     /// </summary>
     public class DataSource
     {
         /// <summary>
         /// 获取商品分类
         /// </summary>
         /// <returns></returns>
         public static string GetCategories()
         {
             Thread.Sleep();//模拟耗时
             return "There are categories";
         }
     }

DataSource

   /// <summary>
     /// 静态字典缓存数据
     /// </summary>
     public class MyCache
     {
         private static Dictionary<string, object> _dictionary = new Dictionary<string, object>();

         public static void Add(string key,object obj)
         {
             _dictionary.Add(key, obj);
         }

         public static bool Exist(string key)
         {
             return _dictionary.ContainsKey(key);
         }

         public static void remove(string key)
         {
             _dictionary.Remove(key);
         }

         public static void removeAll(string key)
         {
             _dictionary = new Dictionary<string, object>();
         }

         public static T Get<T>(string key)
         {
             return (T)_dictionary[key];
         }
     }

MyCache

 /// <summary>
     /// 数据处理类
     /// </summary>
     public class DataProxy
     {
         /// <summary>
         /// 获取商品分类
         /// </summary>
         /// <returns></returns>
         public static string GetCategories()
         {
             if (MyCache.Exist("Categories"))
             {
                 return MyCache.Get<string>("Categories");
             }

             else
             {
                 MyCache.Add("Categories", DataSource.GetCategories());

                 return DataSource.GetCategories();
             }
         }
     }

DataProxy

     class Program
     {

         static void Main(string[] args)
         {
             string cats,cats1, cats2;

             cats = DataProxy.GetCategories();

             Console.WriteLine(cats);

             cats1 = DataProxy.GetCategories();

             Console.WriteLine(cats1);

             cats2 = DataProxy.GetCategories();

             Console.WriteLine(cats2);

             Console.ReadKey();
         }
     }

GetData

经过这样的优化后,网站响应速度一下子就得到了提升

2缓存

上述场景就是对缓存的一种应用,它是系统性能优化的第一步

原因是使用缓存,缩短了获取数据的时间

这里重点讲解的是服务器端数据缓存,它只是缓存的一部分

下面是http请求过程

可以看到几乎各个环节都涉及到了缓存

3缓存进阶

上述只是数据缓存最简单的例子,在实际的开发过程中,我们还会面对更多的情形,下面我来简单的进阶一下

3.1缓存清理

当我们已知一条缓存的数据已经更新,我们该如何做呢?

上述代码已经解决了这个问题,Remove方法:即去掉这个键值对,然后在数据库获取最新的数据

那么如果多条缓存被影响,我们该如何做呢?

上述的RemoveAll方法?当然这是最直接有效的方法,但是这样会造成缓存穿透,在一瞬间丢失所有的缓存,数据库的压力将会骤增

一个比较有效的方法:我们在添加缓存的时候,把缓存的key值与它的数据义务相联系,即命名更加有意义,这样当某部分受到影响的时候,我们可以直接根据命名来确定是否更改

3.2缓存有效性

在使用缓存的过程中,我们遇到更多的情况是:程序根本不知道,数据已经发生变化

面对这种情况,我们一般采取的措施:给缓存加上有效期

在有效期内,直接使用缓存,超过有效期,在数据库获取最新数据并缓存起来

我们也可以同时增加一条线程,来不间断的主动检查缓存有效期,避免只有在使用的时候才检查的被动状态

代码如下:

   /// <summary>
     /// 静态字典缓存数据
     /// </summary>
     public class MyCache
     {
         /// <summary>
         /// 每1个小时主动检查缓存过期项一次
         /// </summary>
         static MyCache()
         {
             Task.Run(() =>
             {
                 Thread.Sleep( * );

                 List<string> keyList = new List<string>(); //过期key集合

                 foreach (var item in _dictionary.Keys)
                 {
                     if (_dictionary[item].Value < DateTime.Now)
                     {
                         keyList.Add(item); //已过期
                     }
                 }

                 keyList.ForEach(p => { _dictionary.Remove(p); });
             });
         }

         private static Dictionary<string, KeyValuePair<object, DateTime>> _dictionary
             = new Dictionary<string, KeyValuePair<object, DateTime>>();

         public static void Add(string key, object obj, int minute = )
         {
             _dictionary.Add(key, new KeyValuePair<object, DateTime>(obj, DateTime.Now.AddMinutes(minute)));
         }

         public static bool Exist(string key)
         {
             return _dictionary.ContainsKey(key);
         }

         public static void remove(string key)
         {
             _dictionary.Remove(key);
         }

         public static void removeAll(string key)
         {
             _dictionary = new Dictionary<string, KeyValuePair<object, DateTime>>();
         }

         public static T Get<T>(string key)
         {
             return (T)_dictionary[key].Key;
         }
     }

MyCache

3.3线程安全

在单线程下,上述缓存简例,是没有问题的,可是我们往往面对的是多线程迸发,那么上述的例子,就会有线程安全问题

在键值对添加这里,如果多个线程访问,就会因为添加相同的键值,而导致程序崩溃

所以我们可以加锁,只允许一个线程先访问,后续的线程进来时判断键值是否已经存在

代码如下

     /// <summary>
     /// 静态字典缓存数据
     /// </summary>
     public class MyCache
     {
         private static object _lock = new object();
         /// <summary>
         /// 每1个小时主动检查缓存过期项一次
         /// </summary>
         static MyCache()
         {
             Task.Run(() =>
             {
                 Thread.Sleep( * );

                 List<string> keyList = new List<string>(); //过期key集合

                 foreach (var item in _dictionary.Keys)
                 {
                     if (_dictionary[item].Value < DateTime.Now)
                     {
                         keyList.Add(item); //已过期
                     }
                 }

                 keyList.ForEach(p => { _dictionary.Remove(p); });
             });
         }

         private static Dictionary<string, KeyValuePair<object, DateTime>> _dictionary
             = new Dictionary<string, KeyValuePair<object, DateTime>>();

         public static void Add(string key, object obj, int minute = )
         {
             lock (_lock)
             {
                 if (_dictionary.ContainsKey(key))
                 {
                     return;
                 }
                 else
                 {
                     _dictionary.Add(key, new KeyValuePair<object, DateTime>(obj, DateTime.Now.AddMinutes(minute)));
                 }
             }
         }

         public static bool Exist(string key)
         {
             return _dictionary.ContainsKey(key);
         }

         public static void remove(string key)
         {
             _dictionary.Remove(key);
         }

         public static void removeAll(string key)
         {
             _dictionary = new Dictionary<string, KeyValuePair<object, DateTime>>();
         }

         public static T Get<T>(string key)
         {
             return (T)_dictionary[key].Key;
         }
     }

MyCache

4适用场景和优劣

没有任何技术是完美的,我们所做的只能是具体问题具体分析

缓存会在够解决一系列问题的同时,带来新的问题,我们所能够做的是扬长避短

4.1适用场景

1数据实时性要求不太高:缓存的本质决定了其一定会有脏数据,即使加了有效期,也会有延迟

2多次请求:如果没有请求多次,那么也没有缓存的必要

2体积小:因为缓存是在程序进程内存里面的,所以空间有限

4.2优劣

优势:能够缩短查询路径,更快的得到响应, 优化系统性能,

劣势:无法确定数据是否是最新的,有所延迟

5结语

至今为止,关于缓存与其他各种技术的相结合和各种关于缓存的框架层出不穷,如果一开始就注其表面,会感到晦涩难以深入,不如透过现象回到本质,以最单纯的想法去理解它,那么反而更容易接近它,只要能够明白这些,那么对于那些立其之上的衍生物,只会是游刃有余

出自:博客园-半路独行

原文地址:https://www.cnblogs.com/banluduxing/p/9238838.html

本文出自于http://www.cnblogs.com/banluduxing 转载请注明出处。