问题标签 [lru]

当用户打开另一个应用程序时，前一个应用程序将被缓存在内存中，除非用户明确地杀死它，或者内存变得太低。随着用户继续使用不同的应用程序，越来越多的应用程序可能会根据 LRU 策略缓存在内存中。

缓存应用程序的数量可能取决于将缓存哪些应用程序以及总可用内存是多少，因为不同的应用程序消耗的内存量不同。

假设总可用内存总是足够的，那么内存中最多可以缓存多少个应用程序？这个数字在不同的 Android 版本中是固定的吗？这取决于设备的参数吗？

在我的带有 Android 4.2 的 nexus 7 上，这个数字似乎是 10。如果你发现它错了，请纠正我。

我正在研究为 android 实现离线模式，但要实现它，我需要实现一个缓存系统。我阅读并且人们建议 LruCache 并在LruCache Example看到了图像示例。现在我不缓存图像，我想缓存对象。例如，我有一个名为“客户”的对象，客户有一个 ID 和一个名称，所以据我了解，我会将其添加到缓存中

Id 是键，Name 是值。

我的问题是，如果我有另一个名为“课程”的对象，我需要一个单独的缓存来解决这个问题吗？因为如果它们在同一个缓存中，可能会有一个与 Courses.Id 相同的 Customer.Id。

或者什么是实现这一点的最佳方法？（第一次实现缓存，也是 android 的新手）。

我对算法 LRU 有一个小问题。如果你有一个有四个块的缓存，你需要多少位来实现这个算法？

我试图了解缓存是如何工作的。我正在研究一个问题以更好地理解这个概念：

给定一个 2 路组关联缓存，块长度为 1 个字，总大小为 16 个长度为 32 位的字，最初为空，并使用最近最少使用的替换策略。显示以下地址是否命中或未命中并列出缓存的最终内容。

地址：

1. 00010001
2. 01101011
3. 00111111
4. 01001000
5. 00011001
6. 01000010
7. 10001001
8. 00000000
9. 01001000
10. 00011100
11. 00110000
12. 11111100
13. 00111010

首先，根据给定的信息，在我看来，将按以下顺序（T=tag，S=set，O=offset）有 2 个偏移位、3 个设置位和 3 个标记位：TTTSSSOO

示例（地址 1）：

标签 = 000 (0)，设置 = 100 (4)，偏移 = 01 (1)

现在，假设这是正确的，在查找上述地址时应该会发生以下情况：

1. Miss，存储在第 4 组，第 0 块
2. Miss，存储在第 2 组，第 0 块
3. 未命中，存储在第 7 组，第 0 块
4. Miss，存储在第 2 组第 1 组中
5. 未命中，存储在第 6 组，第 0 块
6. Miss, 存储在 set 0, block 0
7. Miss，存储在 set 2，block 0（block 0 是 LRU，现在 block 1 变成 LRU）
8. Miss，存储在 set 0，block 1
9. 击中第 2 组，第 1 组
10. 小姐，存储在第 7 组，第 1 块
11. Miss，存储在第 6 组，第 1 块
12. Miss，存储在 set 7，block 0（block 0 是 LRU，现在 block 1 变成 LRU）
13. Miss，存储在 set 6，block 0（block 0 是 LRU，现在 block 1 变成 LRU）

缓存的最终内容应如下所示：

设置 0：01000010、00000000

设置1：空的，空的

第 2 组：10001001、01001000

第 3 组：空的，空的

设置 4：00010001，空

第 5 组：空的，空的

第 6 组：00111010、00110000

第 7 组：11111100、00011100

我对此感到非常困难，所以希望有人可以让我知道我是否走在正确的轨道上。如果这些看起来没问题，我想尝试相同的练习，但使用不同的地址进行进一步练习，以确保我掌握了它。

EDIT1：新地址。

1. 000_100_01
2. 000_010_01
3. 000_001_10
4. 000_001_01
5. 001_010_11
6. 000_001_00
7. 000_010_11
8. 000_010_01
9. 001_110_00
10. 000_100_11
11. 000_000_01
12. 000_101_11
13. 011_010_11

应该喜欢：

1. 未命中，存储在第 4 组块 0 中
2. 未命中，存储在第 2 组块 0 中
3. 未命中，存储在 set 1 块 0 中
4. Miss，存入set 1 block 1，block 0变成LRU
5. Miss，存入set 2 block 1，block 0变成LRU
6. Miss，存入set 1 block 0，block 1变成LRU
7. Miss，存入set 2 block 0，block 1变成LRU
8. 命中，set 2 block 0 变成 LRU
9. 未命中，存储在第 6 组块 0 中
10. 小姐，存储在第 4 组第 1 组中
11. 未命中，存储在 set 0 块 0 中
12. 未命中，存储在第 5 组块 0 中
13. Miss，存入set 2 block 0，block 1变成LRU

我经常在 Python 中进行交互工作，其中涉及一些我不想经常重复的昂贵操作。我通常会运行我经常处理的任何 Python 文件。

如果我写：

我得到这种行为：

也就是说，重新运行文件会清除缓存。这有效：

但是当函数很长时，将其定义放在try块中会感觉很奇怪。我可以这样做：

但感觉很做作（例如，在没有'@'符号的情况下调用装饰器）

有没有一种简单的方法来处理这个问题，比如：

?

My copy of Hacker's Delight is at home, and the web resources I've found aren't clear on this detail.

I have written the following 8-level LRU, using the well-known "row-column square" algorithm. (Is there a better name?).

I would like confirmation of my assumption that the least-recently-used row will be all zeroes. It seems to work, but I don't have the math to prove it to my satisfaction.

So, is this right? Or do I need to compute the minimum Hamming weight for each row?

我正在尝试编写一个模拟 LRU 页面替换的函数。我非常了解 LRU，但在编码时遇到问题。以下内容被传递到 LRU 函数中。用户指定 # 的 1-9 的 20 个字符的引用字符串，该字符串存储在大小为 20 的称为 refString 的数组中。用户输入的帧数 (1-7) 存储在变量 numFrames 中。最后，传入一个名为 frame 的大小为 7 的数组。

这是我的代码，我得到的数字很接近，但并不完全。也许有人可以帮忙！

我开发了一个Python 客户端库，它是 Web API 的客户端包装器：一个不错的功能是本地缓存机制：当库客户端在 Web API 上调用相同的请求时，这将节省时间和带宽在不同的时间。

我的要求很少

1. 应开发缓存（无外部库）并运行 Python 2.6/2.7 环境
2. 该库应提供统一的接口，以便可以使用外部缓存机制（例如：memcached）包装器，这些包装器将被依赖注入
3. 缓存应该是线程安全的
4. 要缓存的内容将是 Web API 响应的 JSON 有效负载。
5. Web API 提供的数据在不同的时间老鼠会有所不同：例如，当前观察到的一个城市的天气可能每小时变化一次，而 15 天的天气预报可能每 5 天左右变化一次。

可以使用的最简单的算法是什么？

我在考虑 LRU（最近最少使用）算法，但我想可以评估其他替代方案 - 我根本不是缓存专家！

这可能很简单，但我无法理解它。谁能给我一个顺序洪水的例子？在我正在阅读的教科书和互联网资源中都有说明

当缓冲区帧数小于文件中的页数时，这将导致读取文件的每一页。这是由 LRU 和重复扫描导致的令人讨厌的情况

# 帧 < # 文件中的页面。

使用 LRU，每次扫描文件都会读取文件的每一页。”

但它到底是什么？为什么会这样？

我在 Android 中实现了一个标准的 LRUCache 来存储对象。每个键都是与存储的对象关联的唯一 ObjectId。我的问题是从缓存中检索对象的唯一方法是通过 ObjectId（无迭代器）。实现 getAll() 方法的最佳方法是什么？另一种选择是将所有 ObjectIds 存储在某个列表中，这样我就可以遍历列表并获取所有 Objects - 但是保存所有 ObjectIds 的最佳方式是什么？

谢谢！