无缝的缓存读取:双存储缓存策略

 

最近在作一个WEB的数据统计的优化，可是因为数据量大，执行一次SQL统计要比较长的时间（通常700ms算是正常）。

正常的作法只要加个缓存就行了。

可是同时业务要求此数据最多1分钟就要更新，并且这一分种内数据可能会有较多变化（并且原系统不太易扩展）。

也就是说缓存1分钟就要失效从新统计，并且用户访问这页还非常频繁，若是使用通常缓存那么用户体验不好并且很容易形成超时。

 

承

看到以上需求，第一个进入我大脑的就是从前作游戏时接触到的DDraw的双缓冲显示方式。

在第一帧显示的同时，正在计算第二帧，这样读取和计算就能够分开了，也就避免了读取时计算，提升了用户体验。

我想固然咱们也能够将这种方式用于缓存的策略中，但这样用空间换取时间的方式仍是得权衡的，由于并非全部时候都值得这么作，但这里我以为这样作应该是最好的方式了。

注：为了能够好好演示，本篇中的缓存都以IEnumerable的形式来存储，固然这个文中原理也能够应用在WebCache中。

这里我使用如下数据结构作为存储单元：

namespace CHCache {
    /// <summary>     /// 缓存介质     /// </summary>     public class Medium {
        /// <summary>         /// 主要存储介质         /// </summary>         public object Primary { get; set; }
        /// <summary>         /// 次要存储介质         /// </summary>         public object Secondary { get; set; }
        /// <summary>         /// 是否正在使用主要存储         /// </summary>         public bool IsPrimary { get; set; }
        /// <summary>         /// 是否正在更新         /// </summary>         public bool IsUpdating { get; set; }
        /// <summary>         /// 是否更新完成         /// </summary>         public bool IsUpdated { get; set; }
    }
}

有了这个数据结构咱们就能够将数据实现两份存储。再利用一些读写策略就能够实现上面咱们讲的缓存方式。

转

整个的缓存咱们使用以下缓存类来控制：

/* * http://www.cnblogs.com/chsword/ * chsword * Date: 2009-3-31 * Time: 17:00 * */ using System;using System.Collections;using System.Collections.Generic;using System.Threading;namespace CHCache {
    /// <summary>     /// 双存储的类     /// </summary>     public class DictionaryCache : IEnumerable {
        /// <summary>         /// 在此缓存构造时初始化字典对象         /// </summary>         public DictionaryCache()
        {
            Store = new Dictionary<string, Medium>();
        }
        public void Add(string key,Func<object> func)
        {
            if (Store.ContainsKey(key)) {//修改，若是已经存在，再次添加时则采用其它线程                 var elem = Store[key];
                if (elem.IsUpdating)return;  //正在写入未命中                 var th = new ThreadHelper(elem, func);//ThreadHelper将在下文说起,是向其它线程传参用的
                var td = new Thread(th.Doit);
                td.Start();
            }
            else {//首次添加时可能也要读取，因此要本线程执行                 Console.WriteLine("Begin first write");
                Store.Add(key, new Medium {IsPrimary = true, Primary =  func()});
                Console.WriteLine("End first write");
            }

        }
        /// <summary>         /// 读取时所用的索引         /// </summary>         /// <param name="key"></param>         /// <returns></returns>         public object this[string key] {
            get {
                if (!Store.ContainsKey(key))return null;
                var elem = Store[key];
                if (elem.IsUpdated) {//若是其它线程更新完毕，则将主次转置                     elem.IsUpdated = false;
                    elem.IsPrimary = !elem.IsPrimary;
                } 
                var ret = elem.IsPrimary ? elem.Primary : elem.Secondary;
                var b = elem.IsPrimary ? " from 1" : " form 2";
                return ret + b;
            }
        }
        Dictionary<string, Medium> Store { get; set; }
        public IEnumerator GetEnumerator() {
            return ((IEnumerable)Store).GetEnumerator();
        }
    }
}

这里我只实现了插入一个缓存，以及读取的方法。

我读取缓存单元的逻辑是这样的

 

从2个不一样缓存读取固然是很容易了，可是比较复杂的就是向缓存写入的过程：

这里读取数据以及写入缓存时我使用了一个委托，在其它线程中仅在须要执行时才会执行。

这里除了首次写入缓存占用主线程时间（读取要等待）之外，其它时间均可以无延时的读取，实现了无缝的缓存。

但咱们在委托中要操做缓存的元素Medium,因此要传递参数进其它线程，因此我这里使用了一个辅助类来传递参数进入其它线程：

using System;namespace CHCache {
    /// <summary>     /// 一个线程Helper，用于帮助多抛出线程时传递参数     /// </summary>     public class ThreadHelper {
        Func<object> Fun { get; set; }
        Medium Medium { get; set; }
        /// <summary>         /// 经过构造函数来传递参数         /// </summary>         /// <param name="m">缓存单元</param>         /// <param name="fun">读取数据的委托</param>         public ThreadHelper(Medium m,Func<object> fun) {
            Medium = m;
            Fun = fun;
        }
        /// <summary>         /// 线程入口，ThreadStart委托所对应的方法         /// </summary>         public void Doit()
        {
            Medium.IsUpdating = true;
            if (Medium.IsPrimary) {
                Console.WriteLine("Begin write to 2.");
                var ret = Fun.Invoke();
                Medium.Secondary = ret;
                Console.WriteLine("End write to 2.");
            }
            else {
                Console.WriteLine("Begin write to 1.");
                var ret = Fun.Invoke();
                Medium.Primary = ret;
                Console.WriteLine("End write to 1.");
            }
            Medium.IsUpdated = true;
            Medium.IsUpdating = false;
        }
    }
}

这样咱们就实现了在另个线程读取数据的过程，这样就在任什么时候候读取数据时都会无延时直接读取了。

结

最后咱们写一个主函数来测试一下效果

/* * http://www.cnblogs.com/chsword/ * chsword * Date: 2009-3-31 * Time: 16:53 */ using System;using System.Threading;namespace CHCache
{
    class Program
    {
        public static void Main(string[] args)
        {
            var cache = new DictionaryCache();
            Console.WriteLine("Init...4s，you can press the CTRL+C to close the console window.");
            while (true)
            {
                cache.Add("1", GetValue);
                Thread.Sleep(1000);
                Console.WriteLine(cache["1"]);
            }
        }
        /// <summary>         /// 获取数据的方法，假设是从数据库读取的，费时约4秒         /// </summary>         /// <returns></returns>         static object GetValue()
        {
            Thread.Sleep(4000);
            return DateTime.Now;
        }
    }
}

获得以下数据：

这样就实现了平滑的读取缓存数据而没有任何等待时间

固然这里还有些问题，好比说传递不一样参数时的解决方法，可是因为我仅是在一个统计时须要这种缓存提升性能，因此暂没有考虑通用的传参方式。

若是你们对这个话题感兴趣，欢迎讨论。