POCO C++库学习和分析 -- Cache

POCO C++库学习和分析 -- Cache
 
1. Cache概述
        在STL::map或者STL::set中，容器的尺寸是没有上限的，数目可以不断的扩充。并且在STL的容器中，元素是不会自动过期的，除非显式的被删除。Poco的Cache可以被看成是STL中容器的一个扩充，容器中的元素会自动过期(即失效)。在Poco实现的Cache框架中，基础的过期策略有两种。一种是LRU(Last Recent Used)，另外一种是基于时间的过期(Time based expiration)。在上述两种过期策略之上，还提供了两者之间的混合。
        下面是相关的类：
        1. LRUCache: 最近使用Cache。在内部维护一个Cache的最大容量M，始终只保存M个元素于Cache内部，当第M+1元素插入Cache中时，最先被放入Cache中的元素将失效。
        2. ExpireCache: 时间过期Cache。在内部统一管理失效时间T，当元素插入Cache后，超过时间T，则删除。
        3. AccessExpireCache: 时间过期Cache。同ExpireCache不同的是，当元素被访问后，重新开始计算该元素的超时时间，而不是只从元素插入时开始计时。
        4. UniqueExpireCache: 时间过期Cache。同ExpireCache不同的是，每一个元素都有自己单独的失效时间。
        5. UniqueAccessExpireCache：时间过期Cache。同AccessExpireCache不同的是，每一个元素都有自己单独的失效时间。
        6. ExpireLRUCache：时间过期和LRU策略的混合体。当时间过期和LRU任一过期条件被触发时，容器中的元素失效。
        7. AccessExpireLRUCache：时间过期和LRU策略的混合体。同ExpireLRUCache相比，当元素被访问后，重新开始计算该元素的超时时间，而不是只从元素插入时开始计时。
        8. UniqueExpireLRUCache：时间过期和LRU策略的混合体。同ExpireLRUCache相比，每一个元素都有自己单独的失效时间。
        9. UniqueAccessExpireLRUCache：时间过期和LRU策略的混合体。同UniqueExpireLRUCache相比，当元素被访问后，重新开始计算该元素的超时时间，而不是只从元素插入时开始计时。
 
 
 
2. Cache的内部结构
2.1 Cache类
        下面是Poco中Cache的类图：

 
        从类图中我们可以看到所有的Cache都有一个对应的strategy类。事实上strategy类负责快速搜索Cache中的过期元素。Cache和strategy采用了Poco中的同步事件机制(POCO C++库学习和分析 -- 通知和事件 （四） )。
 
 
        让我们来看AbstractCache的定义：
[cpp] 
template <class TKey, class TValue, class TStrategy, class TMutex = FastMutex, class TEventMutex = FastMutex>   
class AbstractCache  
    /// An AbstractCache is the inte易做图ce of all caches.   
{  
public:  
    FIFOEvent<const KeyValueArgs<TKey, TValue >, TEventMutex > Add;  
    FIFOEvent<const KeyValueArgs<TKey, TValue >, TEventMutex > Update;  
    FIFOEvent<const TKey, TEventMutex>                         Remove;  
    FIFOEvent<const TKey, TEventMutex>                         Get;  
    FIFOEvent<const EventArgs, TEventMutex>                    Clear;  
  
    typedef std::map<TKey, SharedPtr<TValue > > DataHolder;  
    typedef typename DataHolder::iterator       Iterator;  
    typedef typename DataHolder::const_iterator ConstIterator;  
    typedef std::set<TKey>                      KeySet;  
  
    AbstractCache()  
    {  
        initialize();  
    }  
  
    AbstractCache(const TStrategy& strat): _strategy(strat)  
    {  
        initialize();  
    }  
  
    virtual ~AbstractCache()  
    {  
        uninitialize();  
    }  
  
        // ...........  
  
protected:  
    mutable FIFOEvent<ValidArgs<TKey> > IsValid;  
    mutable FIFOEvent<KeySet>           Replace;  
  
    void initialize()  
        /// Sets up event registration.  
    {  
        Add     += Delegate<TStrategy, const KeyValueArgs<TKey, TValue> >(&_strategy, &TStrategy::onAdd);  
        Update  += Delegate<TStrategy, const KeyValueArgs<TKey, TValue> >(&_strategy, &TStrategy::onUpdate);  
        Remove  += Delegate<TStrategy, const TKey>(&_strategy, &TStrategy::onRemove);  
        Get     += Delegate<TStrategy, const TKey>(&_strategy, &TStrategy::onGet);  
        Clear   += Delegate<TStrategy, const EventArgs>(&_strategy, &TStrategy::onClear);  
        IsValid += Delegate<TStrategy, ValidArgs<TKey> >(&_strategy, &TStrategy::onIsValid);  
        Replace += Delegate<TStrategy, KeySet>(&_strategy, &TStrategy::onReplace);  
    }  
  
    void uninitialize()  
        /// Reverts event registration.  
    {  
        Add     -= Delegate<TStrategy, const KeyValueArgs<TKey, TValue> >(&_strategy, &TStrategy::onAdd );  
        Update  -= Delegate<TStrategy, const KeyValueArgs<TKey, TValue> >(&_strategy, &TStrategy::onUpdate);  
        Remove  -= Delegate<TStrategy, const TKey>(&_strategy, &TStrategy::onRemove);  
        Get     -= Delegate<TStrategy, const TKey>(&_strategy, &TStrategy::onGet);  
        Clear   -= Delegate<TStrategy, const EventArgs>(&_strategy, &TStrategy::onClear);  
        IsValid -= Delegate<TStrategy, ValidArgs<TKey> >(&_strategy, &TStrategy::onIsValid);  
        Replace -= Delegate<TStrategy, KeySet>(&_strategy, &TStrategy::onReplace);  
    }  
  
    void doAdd(const TKey& key, const TValue& val)  
        /// Adds the key value pair to the cache.  
        /// If for the key already an entry exists, it will be overwritten.  
    {

补充：软件开发 , C++ ,