Orchard源码分析 - 缓存管理

    ICacheManager  &   ICacheHolder             

Orchard缓存管理主要通过 ICacheManager 接口对外提供缓存服务. 其实现类DefaultCacheManager的构造函数如下,

DefaultCacheManager(Type component/*此类型是缓存服务消费者的类型名称,在CacheModule中配置注册,

其主要作用是在CacheHolder中创建一个cacheKey,cacheKey使用三元组(Tuple)数组结构,使cacheKey免于冲突,(component类型+用户Key类型+返回值类型)保证cacheKey的唯一性*/

, ICacheHolder cacheHolder)

ICache对象[最小缓存单元]由DefaultCacheHolder类提供,此类内部使用一个线程安全的ConcurrentDictionary来缓存Cache对象[Cache对象为最小缓存单元],此字典就是Orchard缓存的最终存储位置 !

此字典使用三元组(Tuple)做为cache避免key冲突. 获取Cache的原理是:

1. 如果在此字典中用cacheKey[上面说的三元组结构]取到值则直接返回.

2. 如果未取到则new Cache .(此处硬编码写死了ICache的实现类,如果想使用其它Cache实现则必须修改此处)

public ICache<TKey, TResult> GetCache<TKey, TResult>(Type component) {
            var cacheKey = new CacheKey(component, typeof(TKey), typeof(TResult));
            var result = _caches.GetOrAdd(cacheKey, k => new Cache<TKey, TResult>(_cacheContextAccessor));
            return (Cache<TKey, TResult>)result;
        }

    ICache (最小缓存单元)                                

此接口的实现类是Orchard中的一个最小缓存单元. 但此缓存单元并不是直接拿来使用的object,而是需要调用Get(key, acquire)才能获取想要的缓存值 .

Cache类同样使用了线程安全的ConcurrentDictionary来存储键值数据,和DefaultCacheHolder不同的是: 一个Cache对象中,此字典仅有一对键值项.

Cache类Get缓存值的原理是 :

1. 如果用key在ConcurrentDictionary中未取到值,那么将创建一个CacheEntry

2. 如果用key在ConcurrentDictionary中取到值,则更新此CacheEntry

private CacheEntry UpdateEntry(CacheEntry currentEntry, TKey k, Func<AcquireContext<TKey>, TResult> acquire) {
            //在此检测currentEntry中令牌列表中是否有任一令牌过期,如果有一个过期了,则重建CacheEntry,否则CacheEntry保持原样.
            var entry = (currentEntry.Tokens.Any(t => t != null && !t.IsCurrent)) ? CreateEntry(k, acquire) : currentEntry;
            PropagateTokens(entry);
            return entry;
}

注意此key不是上面说的三元组结构的Key,而是用户定义的泛型key !

CacheEntry是一个Cache的内部私有类,CacheEntry中的Result属性为最终有用的值,Cache.Get方法的返回结果就是Result. (千呼万唤始出来..... 很不容易).

   CacheEntry的作用                                       

Orchard缓存的最终值被包装在CacheEntry中,此类内部维护了一个IVolatileToken链表,IVolatileToken是一个过期令牌(内部有一个IsCurrent属性,如果为false则过期,实施过期的代码在UpdateEntry方法中),

1.创建CacheEntry对象时,将回调acquire(context)方法来设置Result属性(即最终缓存值). 这里面要注意context参数,context参数是随着CacheEntry实例创建时一个新的AcquireContext实例,

然后通过AcquireContext构造函数做了一个重要的操作,伪代码为:

context.Monitor=CacheEntry.AddToken

使用缓存的时候,可以调用 Monitor 来将令牌添加到内部链表中.(以下代码风格在Orchard中极为常见)

public IEnumerable<StereotypeDescription> GetStereotypes() {
            return _cacheManager.Get("ContentType.Stereotypes", context => {
                //此处调用Monitor方法的本质是在对应的CacheEntry中的令牌列表中添加一个令牌项
                context.Monitor(_clock.WhenUtc(_clock.UtcNow.AddMinutes(1)));
                return _providers.SelectMany(x => x.GetStereotypes());
            });

        }

2.当回调完成后,将调用CacheEntry.CompactTokens方法来将过期令牌去重

   如何创建过期令牌                                        

namespace Orchard.Caching {
    //所有实现此空接口的类都被视为令牌提供器
    public interface IVolatileProvider : ISingletonDependency {
    }
}

注: 在1.8版本及以前版本 IVolatileProvider接口未被明显使用, 仅标识类型. (将来的版本中可能会利用此空接口做一些自动注入的操作,目前版本仍然是手工注入)

在\Environment\OrchardStart.cs类中注册了所有提供器

     RegisterVolatileProvider<WebSiteFolder, IWebSiteFolder>(builder);
     RegisterVolatileProvider<AppDataFolder, IAppDataFolder>(builder);
     RegisterVolatileProvider<DefaultLockFileManager, ILockFileManager>(builder);
     RegisterVolatileProvider<Clock, IClock>(builder);
     RegisterVolatileProvider<DefaultDependenciesFolder, IDependenciesFolder>(builder);
     RegisterVolatileProvider<DefaultExtensionDependenciesManager, IExtensionDependenciesManager>(builder);
     RegisterVolatileProvider<DefaultAssemblyProbingFolder, IAssemblyProbingFolder>(builder);
     RegisterVolatileProvider<DefaultVirtualPathMonitor, IVirtualPathMonitor>(builder);
     RegisterVolatileProvider<DefaultVirtualPathProvider, IVirtualPathProvider>(builder);

   分析一个最简单的Signals(信号量)              

这是一个最具代表性的过期令牌提供器,在内部使用一个Dictionary来保存所有<键,Token>项,(因为可能有多个服务消费者,但是此类是单例).

1. 当调用 When<T>(T signal) 时,在Dictionary中查找或添加一个Token实例, 用以启用信号量监控.(Token为内部类,实现IVolatileToken,接口. 初始时IsCurrent=true),

此Token被添加到CacheEntry的内部链表中 ,因为是引用类型,当Signals内的字典中的值改变的时候,CacheEntry中的链表值也会改变(引用相同对象, .NET基础知识).

_cacheDuration = _cacheManager.Get("CacheSettingsPart.Duration",
                context => {
                    //监视一个信号,如果此信号被Trigger(触发),则当前令牌被标识过期
                    context.Monitor(_signals.When(CacheSettingsPart.CacheKey));
                    return _workContext.CurrentSite.As<CacheSettingsPart>().DefaultCacheDuration;
                }
            );

2. 当程序另一部分调用此类Trigger方法时,将在Dictionary移除指定的Token并且设置此Token的IsCurrent=false, 标识过期.

//标识令牌过期
_signals.Trigger("MediaProcessing_Saved_" + filter.ImageProfilePartRecord.Name);

 

引用相等的示例( 基础知识 )

void Main()
{
    var a=new Person{N="我是a"};
    var b=new Person{N="我是b"};
    var c=new Person{N="我是c"};
    var dic=new Dictionary<string,object>();
    dic.Add("a",a);
    dic.Add("b",b);
    dic.Add("c",c);
    var list=new List<Object>();
    list.Add(a);
    list.Add(b);
    list.Add(c);
    object o;
    dic.TryGetValue("a",out o);
    ((Person)o).N="你好";
    //字典中与链表中的值  引用是相等的
    Console.Write(System.Object.ReferenceEquals(o,list[0]));   //输出 True
    //因此改变字典中的值, 链表的值也会改变
    Console.Write(list[0].N);   //输出 "你好"
}
class Person
{
public string N;
}

   IAsyncTokenProvider(异步令牌提供器)             

DefaultAsyncTokenProvider类内部有个子类 AsyncVolativeToken : IVolatileToken , 在获取令牌(GetToken)时 , 传递一个Action<Action<IVolatileToken>> task参数 ,

此 task将在线程池中异步执行, 将token => _taskTokens.Add(token) 作为参数传递给方法体

public void QueueWorkItem() {
                // Start a work item to collect tokens in our internal array
                ThreadPool.QueueUserWorkItem(state => {
                    try {
                        _task(token => _taskTokens.Add(token));
                    }
                    catch (Exception e) {
                        Logger.Error(e, "Error while monitoring extension files. Assuming extensions are not current.");
                        _taskException = e;
                    }
                    finally {
                        _isTaskFinished = true;
                    }
                });
            }

extensionEntry = _cacheManager.Get(extensionId, ctx => {
                    var entry = BuildEntry(extensionDescriptor);
                    if (entry != null) {
                        ctx.Monitor(_asyncTokenProvider.GetToken(monitor => {
//此方法体将在线程池中异步执行

//monitor调用时将会向AsyncVolativeToken实例的内部的List<IVolatileToken>中添加token
                            foreach (var loader in _loaders) {
                                loader.Monitor(entry.Descriptor, token => monitor(token));
                            }
                        }));
                    }
                    return entry;
                });

   在缓存获取方法中使用并行                          

先来看看什么是缓存获取方法:

_cacheManager.Get("CacheSettingsPart.Duration",
                context => {
                  //这个方法仅在Cache中ConcurrentDictionary字典中未找到缓存项才执行,

                   //我称此方法体为[ 缓存获取方法体 ]
                   return  XXXXXX;
                }
            );

如果需要在此方法中使用并行执行提高程序效率,那么Orchard 提供了一个IParallelCacheContext 接口,其中有个方法为

IEnumerable<TResult> RunInParallel<T, TResult>(IEnumerable<T> source, Func<T, TResult> selector);

此方法可以独立使用,  也可以在缓存获取方法中使用.

-----------------------------------------

此方法是将 T类型的source序列  中的元素通过selector方法投影到新的   TResult类型对象中 .

T  -> 使用PLINQ 并行执行 –> TResult

具体过程是:

1. 首先判断Disabled属性是否为禁用状态,如果禁用则用 LINQ直接投影,并不会并行执行

2. 通过内部公开类 TaskWithAcquireContext 包装原始序列中的所有元素, 构造函数中传递投影元素的 lamada

然后用第二步中的投影结果 再 并行执行, 每个元素都会调用  Execute方法

// Run tasks in parallel and combine results immediately
var result = tasks
 .AsParallel() // prepare for parallel execution
 .AsOrdered() // preserve initial enumeration order
 .Select(task => task.Execute()) // prepare tasks to run in parallel
.ToArray(); // force evaluation

那么调用Execute方法会做什么事情呢,下面我们要分两种情况:

1. 在缓存获取方法中使用RunInParallel

我们可以看到,如果在缓存方法体里面调用RunInParallel,  _cacheContextAccessor.Current是有值的, _cacheContextAccessor.Current.Monitor 指向当前CacheEntry中的AddToken方法.

未完待续。。。。。。。