一个缓存系统的算法？

lanying 2004-08-11 11:09:01

现在需要实现一个缓存系统，针对某个特定存储过程
如果2次执行存储过程的参数相同，则从缓存取，否则执行，并更新缓存

参数有多个，每个参数固定数目的值

现在的问题是，如何设计算法使得检索缓存有较高的效率？

...全文

173 点赞收藏 12

写回复

12 条回复

切换为时间正序

当前发帖距今超过3年，不再开放新的回复

发表回复

ThinkOut 2004-10-16

帮你UP下！

回复赞

101monster 2004-10-08

呵呵，UP！

回复赞

短歌如风 2004-10-08

你可以用一个类把参数封装起来，作为一个类型。
struct my_param_t
{
int first;
double second;
std::string third;
};
typedef simple_buffer<my_param_t, std::string, std::string (*)(my_param_t const &)> my_buffer_t;
如果无法为它设计一个优秀的散列函数，那就用std::map，只要为它定义一个表达顺序关系的operator <　就可以了：
inline bool operator < (my_param_t const & compared, my_param_t const & compare_to)
{
return (compared.first < compare_to.first) ||
((compared.first == comapre_to.first) && (compared.second < compare_to.second)) ||
((compared.first == compare_to.first) && (compared.second == compare_to.second) && (compared.third < compare_to.third));
}

回复赞

lanying 2004-09-22

回复赞

lanying 2004-09-14

谢谢楼上，但是我的这个存储过程参数比较多，而且参数之间有一定的关系
所以我不知道怎么设计哈希表，希望楼上能给予指导

回复赞

lanying 2004-09-02

谢谢楼上！

回复赞

短歌如风 2004-09-02

当然这种从缓存中删除过期内容时的算法比较简单，不过一般情况下是可以用的，优点是代码简单。如果不满意，还可以设计复杂一些，关键是新加入的内容和刚访问的内容应该插入到线性表的哪个位置。

回复赞

短歌如风 2004-09-02

我大致写了一个简单的实现，楼主可以参考一下：
#include <iostream>
#include <list>
#include <map>
#include <utility>

template<typename param_type, typename result_type, typename processor_type>
class simple_buffer
{
public:
typedef simple_buffer<param_type, result_type, processor_type> this_type;
typedef std::pair<param_type, result_type> list_item_type;
typedef std::list<list_item_type> list_type;
typedef std::map<param_type, typename list_type::iterator> map_type;
private:
const processor_type processor;
list_type list;
map_type map;
const unsigned int max_len;
public:
simple_buffer(unsigned int the_max_len, const processor_type& the_processor)
:max_len(the_max_len),
processor(the_processor)
{
}
result_type process(const param_type& param)
{
map_type::iterator it = map.find(param);
list_type::iterator in_list;
if (it != map.end())
{
in_list = it->second;
list.push_front(*in_list);
list.erase(in_list);
in_list = list.begin();
it->second = in_list;
}
else
{
list.push_front(list_item_type(param, processor(param)));
in_list = list.begin();
map.insert(map_type::value_type(param, in_list));
if (list.size() > max_len)
{
list_type::iterator to_be_erase = list.end();
--to_be_erase;
map.erase(to_be_erase->first);
list.pop_back();
}
}
return in_list->second;
}
result_type operator()(const param_type& param){return process(param);}
};

int test(int a)
{
std::cout << "test is called with parameter of " << a << std::endl;
return a * 10;
}
int main()
{
simple_buffer<int, int, int (*)(int)> buffer(2, test);
std::cout << "\tbuffer(1)=" << buffer(1) << std::endl;
std::cout << "\tbuffer(1)=" << buffer(1) << std::endl;
std::cout << "\tbuffer(2)=" << buffer(2) << std::endl;
std::cout << "\tbuffer(1)=" << buffer(1) << std::endl;
std::cout << "\tbuffer(2)=" << buffer(2) << std::endl;
std::cout << "\tbuffer(1)=" << buffer(1) << std::endl;
std::cout << "\tbuffer(2)=" << buffer(2) << std::endl;
std::cout << "\tbuffer(1)=" << buffer(1) << std::endl;
std::cout << "\tbuffer(3)=" << buffer(3) << std::endl;
std::cout << "\tbuffer(2)=" << buffer(2) << std::endl;
std::cout << "\tbuffer(3)=" << buffer(3) << std::endl;
std::cout << "\tbuffer(2)=" << buffer(2) << std::endl;
std::cout << "\tbuffer(1)=" << buffer(1) << std::endl;
}

回复赞

短歌如风 2004-09-02

应该用一个链表存储所有<参数,结果>，用一个<参数，链表节点指针>的字典来作为索引。
当一次调用在字典中找到时，把对应的链表节点移到表首(之所以用链表就是为了这步操作，顺序表不适于这种操作)，然后取出结果并返回。
当一次调用在字典中没有找到时：
调用存储过程；
把结果放到链表首；
把<参数,链表新节点指针>加入到字典
如果链表长度超过限制，则从字典中删除链表尾相对应的项，并删除链表尾。
字典的实现可以用hash(必须用桶散列，因为要删除)，也可以用BST。

如果是在C++中实现，可以直接使用std::list<std::pair<param_type, result_type> >和std::map<param_type, std::list<std::pair<param_type, result_type> >::iterator>.

回复赞

lanying 2004-09-01

这个版人气太差了

回复赞