Пример #1
0
        void CheckCache()
        {
            // 更新统计信息
            XCache.CheckShowStatics(ref NextShow, ref Total, ShowStatics);

            // 只要访问了实体缓存数据集合,就认为是使用了实体缓存,允许更新缓存数据期间向缓存集合添删数据
            Using = true;

            if (ExpiredTime > DateTime.Now)
            {
                Interlocked.Increment(ref Success);
                return;
            }

            // 建立异步更新任务
            if (_task == null)
            {
                lock (this)
                {
                    if (_task == null)
                    {
                        _task = UpdateCacheAsync();
                        _task.ContinueWith(t => { _task = null; });
                    }
                }
            }
            // 第一次所有线程一起等待结果
            if (Times == 1 && WaitFirst && _task != null)
            {
                _task.Wait();
            }
        }
Пример #2
0
        private TEntity GetItem <TKey2>(IDictionary <TKey2, CacheItem> dic, TKey2 key)
        {
            // 为空的key,直接返回null,不进行缓存查找
            if (key == null)
            {
                return(null);
            }

            // 更新统计信息
            XCache.CheckShowStatics(ref NextShow, ref Total, ShowStatics);

            // 如果找到项,返回
            CacheItem item = null;

            // 如果TryGetValue获取成功,item为空说明同一时间别的线程已做删除操作
            if (dic.TryGetValue(key, out item) && item != null)
            {
                Interlocked.Increment(ref Shoot1);
                // 下面的GetData里会判断过期并处理
                return(GetData(item));
            }

            ClearUp();

            lock (_SyncRoot)
            {
                // 再次尝试获取
                if (dic.TryGetValue(key, out item) && item != null)
                {
                    Interlocked.Increment(ref Shoot2);
                    return(GetData(item));
                }

                // 开始更新数据,然后加入缓存
                TEntity entity = null;
                if (dic == Entities)
                {
                    entity = Invoke(FindKeyMethod, (TKey)(Object)key);
                }
                else
                {
                    entity = Invoke(FindSlaveKeyMethod, key + "");
                }

                if (entity == null && !AllowNull)
                {
                    Interlocked.Increment(ref Invalid);
                }
                else
                {
                    TryAdd(entity);
                }

                return(entity);
            }
        }
Пример #3
0
        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);
            }
        }