.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(5000);//模拟耗时
            return "There are categories"; 
        }
    }

   class Program
    {

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

            Console.WriteLine(cats);

            Console.ReadKey();
        }
    }

 

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

 1.2优化改进

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

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

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

  /// <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];
        }
    }

/// <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();
            }
        }
    }

    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();
        }
    }

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

2缓存

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

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

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

下面是http请求过程

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

3缓存进阶

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

3.1缓存清理

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

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

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

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

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

3.2缓存有效性

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

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

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

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

代码如下:

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

                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 = 60)
        {
            _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;
        }
    }

3.3线程安全

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

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

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

代码如下

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

                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 = 60)
        {
            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;
        }
    }

4适用场景和优劣

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

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

4.1适用场景

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

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

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

4.2优劣

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

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

5结语

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

出自:博客园-半路独行

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

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