社区
数据结构与算法
帖子详情
一个缓存系统的算法?
lanying
2004-08-11 11:09:01
现在需要实现一个缓存系统,针对某个特定存储过程
如果2次执行存储过程的参数相同,则从缓存取,否则执行,并更新缓存
参数有多个,每个参数固定数目的值
现在的问题是,如何设计算法使得检索缓存有较高的效率?
...全文
214
12
打赏
收藏
一个缓存系统的算法?
现在需要实现一个缓存系统,针对某个特定存储过程 如果2次执行存储过程的参数相同,则从缓存取,否则执行,并更新缓存 参数有多个,每个参数固定数目的值 现在的问题是,如何设计算法使得检索缓存有较高的效率?
复制链接
扫一扫
分享
转发到动态
举报
AI
作业
写回复
配置赞助广告
用AI写文章
12 条
回复
切换为时间正序
请发表友善的回复…
发表回复
打赏红包
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
打赏
举报
回复
up
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
打赏
举报
回复
这个版人气太差了
zzwu
2004-08-26
打赏
举报
回复
帮你up一下.
lanying
2004-08-25
打赏
举报
回复
up
详解:大型网站架构演变和知识体系
大型网站架构演变和知识体系 之前也有一些介绍大型网站架构演变的文章,例如LiveJournal的、ebay的,都是非常值得参考的,不过感觉他们讲的更多的是每次演变的结果,而没有很详细的讲为什么需要做这样的演变,再加上近来感觉有不少朋友都很难明白为什么
一个
网站需要那么复杂的技术,于是有了写这篇文章的想法,在这篇文章中将阐述
一个
普通的网站发展成大型网站过程中的一种较为典型的架构演变历程和所需掌握的知识体系,希望能给想从事互联网行业的朋友理清楚核心概念。
Android照片结合LruCache和DiskLruCache Demo源码程序
此为示例代码,如对资源内容有疑问,可以到以下博客地址中留言: http://blog.csdn.net/guolin_blog/article/details/34093441
你知道哪些
缓存
失效
算法
?
缓存
失效
算法
主要是进行
缓存
失效的,当
缓存
中的存储的对象过多时,需要通过一定的
算法
选择出需要被淘汰的对象,
一个
好的
算法
对
缓存
的命中率影响是巨大的。W-TinyLFU是一种高效的
缓存
淘汰
算法
,它是TinyLFU
算法
的一种改进版本,主要用于处理大规模
缓存
系统
中的淘汰问题。主
缓存
是使用SLRU,元.刚进入W-TinyLFU会在窗口
缓存
暂留一会,被挤出窗口
缓存
时,会在过滤器中和主
缓存
中最容易被淘汰的元素进行PK,如果频率大于主
缓存
中这个最容易被淘汰的元素,才能进入主
缓存
。2.淘汰队列头部的数据;
如何设计
一个
多级
缓存
系统
?
在
一个
高并发的分布式
系统
中,
缓存
系统
是必不可少的一部分,大多数情况下,我们需要设计
一个
多级
缓存
系统
到生产中使用,那么如何设计呢?这也是笔者在前一段时间的面试中,被问到的
一个
问题,虽然当时这道题过了,但是面试结束之后对自己的回答不是很满意,所以,再反复思考之后决定分享下自己的设计思路。欢迎留言批评指正。 首先我们需要明白,什么是
一个
多级
缓存
系统
,它有什么用。所谓多级
缓存
系统
,就是指在
一个
系统
的...
缓存
淘汰
算法
LRU
1 概述 LRU(Least Recently Used)
算法
是一种
缓存
淘汰
算法
,当
系统
的
缓存
过大,达到删除
缓存
的阀值时,最先删除最久没有被使用过的数据,被用于操作
系统
和Redis数据库中。 LRU的底层是由哈希
算法
+链表组成的。哈希
算法
具有查找高效的优点,却没法保存添加顺序,因此采用链表记录数据的使用顺序。说白了就是数据被存为两份,哈希和链表各一份。在没有达到
缓存
上限时候,它两相安无事,当达到
缓存
上限时,根据链表中保存的使用顺序进行删除。 2 图解数据移动顺序 假设
系统
缓存
的上限为3个节点 2.1 向
缓存
数据结构与算法
33,027
社区成员
35,335
社区内容
发帖
与我相关
我的任务
数据结构与算法
数据结构与算法相关内容讨论专区
复制链接
扫一扫
分享
社区描述
数据结构与算法相关内容讨论专区
社区管理员
加入社区
获取链接或二维码
近7日
近30日
至今
加载中
查看更多榜单
社区公告
暂无公告
试试用AI创作助手写篇文章吧
+ 用AI写文章