/// <summary>定期检查实体，如果过期，则触发保存</summary>
void CheckExpire(Object state)
{
var hold = HoldCache;
// 独占缓存不删除缓存，仅判断自动保存
if (hold && !AutoSave)
{
return;
}
// 加锁后把缓存集合拷贝到数组中，避免后面遍历的时候出现多线程冲突
CacheItem[] cs = null;
if (Entities.Count <= 0)
{
return;
}
lock (Entities)
{
if (Entities.Count <= 0)
{
return;
}
cs = new CacheItem[Entities.Count];
Entities.Values.CopyTo(cs, 0);
}
if (cs == null || cs.Length < 0)
{
return;
}
var list = new List <CacheItem>();
foreach (var item in cs)
{
// 是否过期
// 单对象缓存每次缓存的时候，设定一个将来的过期时间，然后以后只需要比较过期时间和当前时间就可以了
if (item.Expired)
{
if (item.Entity != null)
{
// 自动保存
if (AutoSave && item.NextSave <= DateTime.Now)
{
// 捕获异常，不影响别人
try
{
// 需要在原连接名表名里面更新对象
AutoUpdate(item, "定时检查过期");
}
catch { }
}
if (!hold)
{
item.Entity = null;
}
}
if (!hold)
{
list.Add(item);
}
}
}
// 独占缓存不删除缓存
if (hold)
{
return;
}
// 从缓存中删除，必须加锁
if (list.Count > 0)
{
lock (Entities)
{
foreach (var item in list)
{
if (Entities.ContainsKey(item.Key))
{
Entities.Remove(item.Key);
if (Debug)
{
DAL.WriteLog("定时检查，删除超时Key={0}", item.Key);
}
}
}
//Using = Entities.Count > 0;
}
if (SlaveEntities.Count > 0)
{
lock (SlaveEntities)
{
foreach (var item in list)
{
if (!item.SlaveKey.IsNullOrWhiteSpace())
{
SlaveEntities.Remove(item.SlaveKey);
}
}
}
}
}
}
private TEntity GetItem(TKey key)
{
// 为空的key，直接返回null，不进行缓存查找
if (key == null)
{
return(null);
}
if (Type.GetTypeCode(typeof(TKey)) == TypeCode.String)
{
String value = key as String;
if (String.IsNullOrEmpty(value))
{
return(null);
}
}
// 更新统计信息
XCache.CheckShowStatics(ref NextShow, ref Total, ShowStatics);
// 如果找到项，返回
CacheItem item = null;
if (Entities.TryGetValue(key, out item) && item != null)
{
Interlocked.Increment(ref Shoot1);
return(GetItem(item, key));
}
// 加锁
lock (Entities)
{
// 如果找到项，返回
if (Entities.TryGetValue(key, out item) && item != null)
{
Interlocked.Increment(ref Shoot2);
return(GetItem(item, key));
}
item = new CacheItem();
item.Key = key;
//队列满时，移除最老的一个
if (Entities.Count >= MaxEntity)
{
TKey keyFirst = GetFirstKey();
if (keyFirst != null && (Type.GetTypeCode(typeof(TKey)) != TypeCode.String || String.IsNullOrEmpty(keyFirst as String)))
{
CacheItem item2 = null;
if (Entities.TryGetValue(keyFirst, out item2) && item2 != null)
{
if (Debug)
{
DAL.WriteLog("单实体缓存{0}超过最大数量限制{1}，准备移除第一项{2}", typeof(TEntity).FullName, MaxEntity, keyFirst);
}
Entities.Remove(keyFirst);
//自动保存
if (AutoSave && item2.Entity != null)
{
InvokeFill(delegate { item2.Entity.Update(); });
}
}
}
}
//查找数据
//TEntity entity = FindKeyMethod(key);
TEntity entity = null;
InvokeFill(delegate { entity = FindKeyMethod(key); });
if (entity != null || AllowNull)
{
item.Entity = entity;
item.ExpireTime = DateTime.Now.AddSeconds(Expriod);
if (!Entities.ContainsKey(key))
{
Entities.Add(key, item);
}
}
else
{
Interlocked.Increment(ref Invalid);
}
return(entity);
}
}
/// <summary>移除依赖于某个数据表的缓存</summary>
/// <param name="tableName">数据表</param>
public static void Remove(String tableName)
{
//请求级缓存
if (Kind == CacheKinds.请求级缓存)
{
var cs = Items;
if (cs == null)
{
return;
}
List <Object> toDel = new List <Object>();
foreach (Object obj in cs.Keys)
{
String str = obj as String;
if (!String.IsNullOrEmpty(str) && (str.StartsWith(_dst) || str.StartsWith(_int)))
{
CacheItem ci = cs[obj] as CacheItem;
if (ci != null && ci.IsDependOn(tableName))
{
toDel.Add(obj);
}
}
}
foreach (Object obj in toDel)
{
cs.Remove(obj);
}
return;
}
//静态缓存
lock (_TableCache)
{
// 2011-03-11 大石头 这里已经成为性能瓶颈，将来需要优化，瓶颈在于_TableCache[sql]
// 2011-11-22 大石头 改为遍历集合，而不是键值，避免每次取值的时候都要重新查找
List <String> toDel = new List <String>();
foreach (var item in _TableCache)
{
if (item.Value.IsDependOn(tableName))
{
toDel.Add(item.Key);
}
}
foreach (String sql in toDel)
{
_TableCache.Remove(sql);
}
}
lock (_IntCache)
{
List <String> toDel = new List <String>();
foreach (var item in _IntCache)
{
if (item.Value.IsDependOn(tableName))
{
toDel.Add(item.Key);
}
}
foreach (String sql in toDel)
{
_IntCache.Remove(sql);
}
}
}
