内存缓存MemoryCache

内存缓存MemoryCache实现了ICache接口，Redis同样实现了ICache接口，两者在缓存操作上达到了高度抽象统一。应用设计时一律使用ICache接口，开发环境装配为MemoryCache，生产环境根据分布式需要可以装配为Redis。如果应用系统没有分布式需求，继续使用MemoryCache更好。

超高性能

MemoryCache核心是并行字典ConcurrentDictionary，由于省去了序列化和网络通信，使得它具有千万级超高性能（普通台式机实测2.87亿tps）。

MemoryCache支持过期时间，默认容量10万个，未过期key超过该值后，每60秒根据LRU清理溢出部分。

常用于进程内千万级以下数据缓存场景。

本机测试数据如下（I9-10900K）：

1.  
   Test v1.0.0.1130 Build 2021-01-31 19:33:32 .NETCoreApp,Version=v5.0
2.  
   Test
3.  
   Memory性能测试[顺序]，批大小[0]，逻辑处理器 20 个
4.  
   测试 10,000,000 项， 1 线程
5.  
   赋值 耗时 934ms 速度 10,706,638 ops
6.  
   读取 耗时 989ms 速度 10,111,223 ops
7.  
   删除 耗时 310ms 速度 32,258,064 ops
8.  
   累加 耗时 584ms 速度 17,123,287 ops
9.  
   测试 20,000,000 项， 2 线程
10.  
    赋值 耗时 927ms 速度 21,574,973 ops
11.  
    读取 耗时 1,024ms 速度 19,531,250 ops
12.  
    删除 耗时 319ms 速度 62,695,924 ops
13.  
    累加 耗时 594ms 速度 33,670,033 ops
14.  
    测试 40,000,000 项， 4 线程
15.  
    赋值 耗时 1,011ms 速度 39,564,787 ops
16.  
    读取 耗时 1,039ms 速度 38,498,556 ops
17.  
    删除 耗时 1,636ms 速度 24,449,877 ops
18.  
    累加 耗时 608ms 速度 65,789,473 ops
19.  
    测试 80,000,000 项， 8 线程
20.  
    赋值 耗时 989ms 速度 80,889,787 ops
21.  
    读取 耗时 1,227ms 速度 65,199,674 ops
22.  
    删除 耗时 1,858ms 速度 43,057,050 ops
23.  
    累加 耗时 675ms 速度 118,518,518 ops
24.  
    测试 200,000,000 项， 20 线程
25.  
    赋值 耗时 1,644ms 速度 121,654,501 ops
26.  
    读取 耗时 1,807ms 速度 110,680,686 ops
27.  
    删除 耗时 2,936ms 速度 68,119,891 ops
28.  
    累加 耗时 1,569ms 速度 127,469,725 ops
29.  
    测试 200,000,000 项， 64 线程
30.  
    赋值 耗时 1,686ms 速度 118,623,962 ops
31.  
    读取 耗时 1,877ms 速度 106,553,010 ops
32.  
    删除 耗时 695ms 速度 287,769,784 ops
33.  
    累加 耗时 1,585ms 速度 126,182,965 ops
34.  
    总测试数据：2,200,000,042

ICache接口

ICache是缓存抽象接口，主要实现是MemoryCache和Redis

1.  
   /// <summary>缓存接口</summary>
2.  
   public interface ICache
3.  
   {
4.  
   #region 属性
5.  
   /// <summary>名称</summary>
6.  
   String Name { get; }
7.  
   /// <summary>默认缓存时间。默认0秒表示不过期</summary>
8.  
   Int32 Expire { get; set; }
9.  
   /// <summary>获取和设置缓存，永不过期</summary>
10.  
    /// <param name="key"></param>
11.  
    /// <returns></returns>
12.  
    Object this[String key] { get; set; }
13.  
    /// <summary>缓存个数</summary>
14.  
    Int32 Count { get; }
15.  
    /// <summary>所有键</summary>
16.  
    ICollection<String> Keys { get; }
17.  
    #endregion
18.  
    #region 基础操作
19.  
    /// <summary>是否包含缓存项</summary>
20.  
    /// <param name="key"></param>
21.  
    /// <returns></returns>
22.  
    Boolean ContainsKey(String key);
23.  
    /// <summary>设置缓存项</summary>
24.  
    /// <param name="key">键</param>
25.  
    /// <param name="value">值</param>
26.  
    /// <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="Expire"/></param>
27.  
    /// <returns></returns>
28.  
    Boolean Set<T>(String key, T value, Int32 expire = -1);
29.  
    /// <summary>设置缓存项</summary>
30.  
    /// <param name="key">键</param>
31.  
    /// <param name="value">值</param>
32.  
    /// <param name="expire">过期时间</param>
33.  
    /// <returns></returns>
34.  
    Boolean Set<T>(String key, T value, TimeSpan expire);
35.  
    /// <summary>获取缓存项</summary>
36.  
    /// <param name="key">键</param>
37.  
    /// <returns></returns>
38.  
    T Get<T>(String key);
39.  
    /// <summary>批量移除缓存项</summary>
40.  
    /// <param name="keys">键集合</param>
41.  
    /// <returns></returns>
42.  
    Int32 Remove(params String[] keys);
43.  
    /// <summary>清空所有缓存项</summary>
44.  
    void Clear();
45.  
    /// <summary>设置缓存项有效期</summary>
46.  
    /// <param name="key">键</param>
47.  
    /// <param name="expire">过期时间</param>
48.  
    Boolean SetExpire(String key, TimeSpan expire);
49.  
    /// <summary>获取缓存项有效期</summary>
50.  
    /// <param name="key">键</param>
51.  
    /// <returns></returns>
52.  
    TimeSpan GetExpire(String key);
53.  
    #endregion
54.  
    #region 集合操作
55.  
    /// <summary>批量获取缓存项</summary>
56.  
    /// <typeparam name="T"></typeparam>
57.  
    /// <param name="keys"></param>
58.  
    /// <returns></returns>
59.  
    IDictionary<String, T> GetAll<T>(IEnumerable<String> keys);
60.  
    /// <summary>批量设置缓存项</summary>
61.  
    /// <typeparam name="T"></typeparam>
62.  
    /// <param name="values"></param>
63.  
    /// <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="Expire"/></param>
64.  
    void SetAll<T>(IDictionary<String, T> values, Int32 expire = -1);
65.  
    /// <summary>获取列表</summary>
66.  
    /// <typeparam name="T">元素类型</typeparam>
67.  
    /// <param name="key">键</param>
68.  
    /// <returns></returns>
69.  
    IList<T> GetList<T>(String key);
70.  
    /// <summary>获取哈希</summary>
71.  
    /// <typeparam name="T">元素类型</typeparam>
72.  
    /// <param name="key">键</param>
73.  
    /// <returns></returns>
74.  
    IDictionary<String, T> GetDictionary<T>(String key);
75.  
    /// <summary>获取队列</summary>
76.  
    /// <typeparam name="T">元素类型</typeparam>
77.  
    /// <param name="key">键</param>
78.  
    /// <returns></returns>
79.  
    IProducerConsumer<T> GetQueue<T>(String key);
80.  
    /// <summary>获取栈</summary>
81.  
    /// <typeparam name="T">元素类型</typeparam>
82.  
    /// <param name="key">键</param>
83.  
    /// <returns></returns>
84.  
    IProducerConsumer<T> GetStack<T>(String key);
85.  
    /// <summary>获取Set</summary>
86.  
    /// <typeparam name="T"></typeparam>
87.  
    /// <param name="key"></param>
88.  
    /// <returns></returns>
89.  
    ICollection<T> GetSet<T>(String key);
90.  
    #endregion
91.  
    #region 高级操作
92.  
    /// <summary>添加，已存在时不更新</summary>
93.  
    /// <typeparam name="T">值类型</typeparam>
94.  
    /// <param name="key">键</param>
95.  
    /// <param name="value">值</param>
96.  
    /// <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="Cache.Expire"/></param>
97.  
    /// <returns></returns>
98.  
    Boolean Add<T>(String key, T value, Int32 expire = -1);
99.  
    /// <summary>设置新值并获取旧值，原子操作</summary>
100.  
     /// <remarks>
101.  
     /// 常常配合Increment使用，用于累加到一定数后重置归零，又避免多线程冲突。
102.  
     /// </remarks>
103.  
     /// <typeparam name="T">值类型</typeparam>
104.  
     /// <param name="key">键</param>
105.  
     /// <param name="value">值</param>
106.  
     /// <returns></returns>
107.  
     T Replace<T>(String key, T value);
108.  
     /// <summary>尝试获取指定键，返回是否包含值。有可能缓存项刚好是默认值，或者只是反序列化失败，解决缓存穿透问题</summary>
109.  
     /// <typeparam name="T">值类型</typeparam>
110.  
     /// <param name="key">键</param>
111.  
     /// <param name="value">值。即使有值也不一定能够返回，可能缓存项刚好是默认值，或者只是反序列化失败</param>
112.  
     /// <returns>返回是否包含值，即使反序列化失败</returns>
113.  
     Boolean TryGetValue<T>(String key, out T value);
114.  
     /// <summary>累加，原子操作</summary>
115.  
     /// <param name="key">键</param>
116.  
     /// <param name="value">变化量</param>
117.  
     /// <returns></returns>
118.  
     Int64 Increment(String key, Int64 value);
119.  
     /// <summary>累加，原子操作</summary>
120.  
     /// <param name="key">键</param>
121.  
     /// <param name="value">变化量</param>
122.  
     /// <returns></returns>
123.  
     Double Increment(String key, Double value);
124.  
     /// <summary>递减，原子操作</summary>
125.  
     /// <param name="key">键</param>
126.  
     /// <param name="value">变化量</param>
127.  
     /// <returns></returns>
128.  
     Int64 Decrement(String key, Int64 value);
129.  
     /// <summary>递减，原子操作</summary>
130.  
     /// <param name="key">键</param>
131.  
     /// <param name="value">变化量</param>
132.  
     /// <returns></returns>
133.  
     Double Decrement(String key, Double value);
134.  
     #endregion
135.  
     #region 事务
136.  
     /// <summary>提交变更。部分提供者需要刷盘</summary>
137.  
     /// <returns></returns>
138.  
     Int32 Commit();
139.  
     /// <summary>申请分布式锁</summary>
140.  
     /// <param name="key">要锁定的key</param>
141.  
     /// <param name="msTimeout"></param>
142.  
     /// <returns></returns>
143.  
     IDisposable AcquireLock(String key, Int32 msTimeout);
144.  
     #endregion
145.  
     #region 性能测试
146.  
     /// <summary>多线程性能测试</summary>
147.  
     /// <param name="rand">随机读写。顺序，每个线程多次操作一个key；随机，每个线程每次操作不同key</param>
148.  
     /// <param name="batch">批量操作。默认0不分批，分批仅针对随机读写，对顺序读写的单key操作没有意义</param>
149.  
     Int64 Bench(Boolean rand = false, Int32 batch = 0);
150.  
     #endregion
151.  
     }

基本用法

添删改查基本功能，Get/Set/Count/ContainsKey/Remove

1.  
   var ic = new MemoryCache();
2.  
   var key = "Name";
3.  
   var key2 = "Company";
4.  
   ic.Set(key, "大石头");
5.  
   ic.Set(key2, "新生命");
6.  
   Assert.Equal("大石头", ic.Get<String>(key));
7.  
   Assert.Equal("新生命", ic.Get<String>(key2));
8.  
   var count = ic.Count;
9.  
   Assert.True(count >= 2);
10.  
    // Keys
11.  
    var keys = ic.Keys;
12.  
    Assert.True(keys.Contains(key));
13.  
    // 过期时间
14.  
    ic.SetExpire(key, TimeSpan.FromSeconds(1));
15.  
    var ts = ic.GetExpire(key);
16.  
    Assert.True(ts.TotalSeconds > 0 && ts.TotalSeconds < 2, "过期时间");
17.  
    var rs = ic.Remove(key2);
18.  
    Assert.Equal(1, rs);
19.  
    Assert.False(ic.ContainsKey(key2));
20.  
    ic.Clear();
21.  
    Assert.True(ic.Count == 0);

其中Set的第三个参数支持过期时间，单位秒。

集合操作

SetAll/GetAll 是高吞吐的关键，其中SetAll第二参数支持过期时间，单位秒

1.  
   var ic = new MemoryCache();
2.  
   var dic = new Dictionary<String, String>
3.  
   {
4.  
   ["111"] = "123",
5.  
   ["222"] = "abc",
6.  
   ["大石头"] = "学无先后达者为师"
7.  
   };
8.  
   ic.SetAll(dic);
9.  
   var dic2 = ic.GetAll<String>(dic.Keys);
10.  
    Assert.Equal(dic.Count, dic2.Count);
11.  
    foreach (var item in dic)
12.  
    {
13.  
    Assert.Equal(item.Value, dic2[item.Key]);
14.  
    }

高级操作

MemoryCache有几个非常好用的高级操作，全部都是线程安全：

• Add。添加，已存在时不更新，常用于锁争夺。例如，可用于判断指定订单是否处理过，加上过期时间，就是我们经常说的多少小时去重。

• Replace。设置新值并获取旧值，原子操作

• TryGetValue。尝试获取指定键，返回是否包含值。有可能缓存项刚好是默认值

• Increment。累加

• Decrement。累减

缓存过期策略

MemoryCache内置LRU淘汰算法，当缓存项超过最大值Capacity（默认10万）时，剔除最久未使用的缓存项，以避免内存占用过大。

缓存项未达到最大值Capacity时，MemoryCache定时检查并剔除过期项。