concurrent_lru_cache模板类

namespace tbb {
 template <typename key_type,
 typename value_type,
 typename value_functor_type = value_type (*)(key_type) >
 class concurrent_lru_cache{
 private:
 class handle_object;
 public:
 typedef handle_object handle;
 public:
 concurrent_lru_cache(value_functor_type f,std::size_t number_of_lru_history_items);
 handle_object operator()(key_type k);
 private:
 struct handle_move_t;
 class handle_object {
 public:
 handle_object(handle_move_t m);
 operator handle_move_t();
 value_type& value();
 ~handle_object();
 friend handle_move_t move(handle_object& h);
 private:
 void operator=(handle_object&);
 handle_object(handle_object &);
 };
};
 }

The following table provides additional information on the members of this template class.

Member	Description
concurrent_lru_cache(value_function_type f,std::size_tnumber_of_lru_history_items);	Constructs an empty cache with a number_of_lru_history_items maximum number of stored unused objects, and f function object returning new values.
handle_object operator[](key_type k)	Search the container for a pair with given key. If the pair is not found, the user provided function object is called to get the value and insert it into the container. Returns: handle_object pointing to the matching value.
~ concurrent_lru_cache ()	Destroys all items in the container, and the container itself, so that it can no longer be used.
handle_object class	More Info
handle_move_t class	This is an instrumental class to allow certain conversions that allow ownership transfer between instances of handle_object objects. As well it allowshandle_object objects to be passed to and returned from functions. The class has no members other than holding a reference to value object in LRU cache container and a pointer to the container itself.

handle_object class

LRU Cache 实现

// A simple LRU cache written in C++
// Hash map + doubly linked list
#include <iostream>
#include <vector>
#include <ext/hash_map>
using namespace std;
using namespace __gnu_cxx;


template <class K, class T>
struct Node{
    K key;
    T data;
    Node *prev, *next;
};


template <class K, class T>
class LRUCache{
public:
    LRUCache(size_t size){
        entries_ = new Node<K,T>[size];
        for(int i=0; i<size; ++i)// 存储可用结点的地址
            free_entries_.push_back(entries_+i);
        head_ = new Node<K,T>;
        tail_ = new Node<K,T>;
        head_->prev = NULL;
        head_->next = tail_;
        tail_->prev = head_;
        tail_->next = NULL;
    }
    ~LRUCache(){
        delete head_;
        delete tail_;
        delete[] entries_;
    }
    void Put(K key, T data){
        Node<K,T> *node = hashmap_[key];
        if(node){ // node exists
            detach(node);
            node->data = data;
            attach(node);
        }
        else{
            if(free_entries_.empty()){// 可用结点为空，即cache已满
                node = tail_->prev;
                detach(node);
                hashmap_.erase(node->key);
            }
            else{
                node = free_entries_.back();
                free_entries_.pop_back();
            }
            node->key = key;
            node->data = data;
            hashmap_[key] = node;
            attach(node);
        }
    }
    T Get(K key){
        Node<K,T> *node = hashmap_[key];
        if(node){
            detach(node);
            attach(node);
            return node->data;
        }
        else{// 如果cache中没有，返回T的默认值。与hashmap行为一致
            return T();
        }
    }
private:
    // 分离结点
    void detach(Node<K,T>* node){
        node->prev->next = node->next;
        node->next->prev = node->prev;
    }
    // 将结点插入头部
    void attach(Node<K,T>* node){
        node->prev = head_;
        node->next = head_->next;
        head_->next = node;
        node->next->prev = node;
    }
private:
    hash_map<K, Node<K,T>* > hashmap_;
    vector<Node<K,T>* > free_entries_; // 存储可用结点的地址
    Node<K,T> *head_, *tail_;
    Node<K,T> *entries_; // 双向链表中的结点
};


int main(){
    hash_map<int, int> map;
    map[9]= 999;
    cout<<map[9]<<endl;
    cout<<map[10]<<endl;
    LRUCache<int, string> lru_cache(100);
    lru_cache.Put(1, "one");
    cout<<lru_cache.Get(1)<<endl;
    if(lru_cache.Get(2) == "")
        lru_cache.Put(2, "two");
    cout<<lru_cache.Get(2);
    return 0;
}