对于一个对性能要求较高的应用程序,使用缓存似乎是必然的选择。分布式系统通常选择分布式的缓存组件,如memCache。而对于小型系统而言,memCache太沉重了,另外序列化的损失也让我放弃它重新实现InProc的数据缓存。
LRU(Least Recent Used)是一种常用的缓存淘汰方式,在这里通过一个双向链表实现。
public class SimpleLRU<T> : ILRU<T>
{
private readonly LinkedList<T> _linklist = new LinkedList<T>();
private readonly int _maxitem;
private readonly int _removeRate;
/// <summary>
/// 在淘汰时和过期时通知缓存字典移除缓存
/// </summary>
private readonly Action<LinkedListNode<T>> onRemoveNode;
public SimpleLRU(int maxitem, int removeRate, Action<LinkedListNode<T>> onRemoveNode)
{
_maxitem = maxitem;
_removeRate = removeRate;
this.onRemoveNode = onRemoveNode;
}
/// <summary>
/// 移除一个缓存项,通常在显示标记缓存过期时使用
/// </summary>
public void Remove(LinkedListNode<T> node)
{
_linklist.Remove(node);
onRemoveNode(node);
}
/// <summary>
/// 标记缓存刚使用过
/// </summary>
public void MarkUse(LinkedListNode<T> node)
{
if(node.List!=null)
_linklist.Remove(node);
_linklist.AddFirst(node);
}
/// <summary>
/// 新增一个缓存项
/// </summary>
public LinkedListNode<T> AddNew(T value)
{
var n = _linklist.AddFirst(value);
AutoKnockOut();
return n;
}
/// <summary>
/// 当容量超出最大容量时,按比例淘汰一部分
/// </summary>
public void AutoKnockOut()
{
if (_linklist.Count > _maxitem)
RemoveFromEnd(_maxitem * _removeRate / 100);
}
private void RemoveFromEnd(int n)
{
if (_linklist.Count < n)
{
return;
}
for (; n > 0; n--)
{
Remove(_linklist.Last);
}
}
/// <summary>
/// 当前缓存大小
/// </summary>
public int Count
{
get { return _linklist.Count; }
}
}
缓存容器的代码实现:
public class Cache<TKey, TValue>
{
private class CacheItem
{
public LinkedListNode<TKey> node;
public TValue value;
}
private readonly Dictionary<TKey, CacheItem> _dic;
private readonly ILRU<TKey> _linklist;
public Cache(int maxItems, int removeRatio)
{
_dic = new Dictionary<TKey, CacheItem>(1000);
_linklist = new SimpleLRU<TKey>(maxItems, removeRatio, OnRemoveNode);
}
/// <summary>
/// 从缓冲中淘汰
/// </summary>
void OnRemoveNode(LinkedListNode<TKey> node)
{
_dic.Remove(node.Value);
}
/// <summary>
/// 标记缓存过期
/// </summary>
public void Remove(TKey key)
{
lock (this)
{
CacheItem item;
if (_dic.TryGetValue(key, out item))
{
_linklist.Remove(item.node);
}
}
}
/// <summary>
/// 设置一个缓存,如果已经存在则更新
/// </summary>
public void Set(TKey key, TValue value)
{
CacheItem item;
lock (this)
{
if (_dic.TryGetValue(key, out item))
{
item.value = value;
_linklist.MarkUse(item.node);
}
else
{
item = new CacheItem { node = _linklist.AddNew(key), value = value };
_dic.Add(key, item);
}
}
}
/// <summary>
/// 获取一个缓存项
/// </summary>
public bool Get(TKey key, out TValue value)
{
CacheItem item;
lock (this)
{
if (_dic.TryGetValue(key, out item))
{
_linklist.MarkUse(item.node);
value = item.value;
return true;
}
}
value = default(TValue);
return false;
}
public int Count
{
get
{
return _linklist.Count;
}
}
}
由于缓存可能存在并发,线程同步是最难以处理的事情,这里用了同步锁,强行将请求串行化来回避并发带来的问题,当然性能不是最佳的。
-------------------------------------------------------------------------------
性能测试:
测试机器:
CPU:AMD Athlon*2 4800+ (2.5GHz) Memory:2G
测试结果正如先前估计的一样,单线程下表现优异,在家里的破机器上读取速度接近千万/秒,写速度也达到百万/秒。而在多线程的环境下,性能大幅降低,并发越多性能下降越厉害,不过50个线程并发读写同一个缓存可能已经是极限情况,这时读取速度大约20万/秒,写速度10万/秒,对于多数应用,应该也可以接受。
如果你有更好的实现办法,不妨留言或者邮件告诉我,感激不尽。
补充:测试代码中使用的“线程”并非真正的线程(Thread),而是并行库中的任务,实际的线程可能由并行库根据机器的CPU核心数量决定。虽然不是真正的线程,但是实际上模拟了大并发下的真实场景。
联系客服