Java 时钟缓存算法

我想了解时钟缓存替换策略的原理

当它开始工作时会发生什么？ 例如，缓存大小为5。 因此，首先我们向缓存中添加5个随机对象。当我认为所有这些对象最初都将具有clockbit=0时，我是真的吗？ 当第六个物体出现时，我们必须为它找个地方。 我们是否应该尝试在没有时钟指针的情况下在缓存中查找相同的对象（只是ifInCache（comingObject））？ 如果缓存中没有这样的对象，会发生什么？ 时钟指针的起始位置在哪里

---

我读了很多文章，只是想了解有关时钟的主要问题。

我认为你把事情弄得太复杂了。人们使用这种方法的原因是它非常简单

这样可以避免更换最近使用的Entry

private final Object[] objects = new Object[5];
private final boolean[] referenced = new boolean[objects.length];
private int clock = 0;

public Object getOrCache(Object obj) {
    for (int i = 0, objectsLength = objects.length; i < objectsLength; i++) {
        Object o = objects[i];
        if (obj.equals(o)) {
            referenced[i] = true;
            return obj;
        }
    }
    while(referenced[clock]) {
        referenced[clock] = false;
        incrClock();
    }
    objects[clock] = obj;
    incrClock();
    return obj;
}

private void incrClock() {
    if (++clock >= objects.length)
        clock = 0;
}

当我认为所有这些对象最初都将具有clockbit=0时，我是真的吗

如果未引用它们，则为“是”

我们是否应该尝试在没有时钟指针的情况下在缓存中查找相同的对象（只是ifInCache（comingObject））

是的，您必须检查对象是否已经在缓存中。如果是，则参考位（时钟位）将设置为1

如果缓存中没有这样的对象，会发生什么？时钟指针的起始位置在哪里

如果对象不在缓存中，则在时钟指针处检查对象。如果手的位置尚未满，则手的位置将是缓存中的最后一个位置，否则在两次缓存查找之间保持不变（它将由查找本身递增）

示例（缓存大小=5）：

• 添加

  A

  ->在0之前和1之后的手
• 添加

  B

  ->在前1处和后2处交
• 添加

  C

  ->在前2处和后3处交
• 添加

  D

  ->在前3处和后4处交
• 添加

  E

  ->在4之前和0之后的手
• 在0处添加

  F

  ->hand，检查

  A

  的引用位，如果为0，则替换并增加hand，否则仅增加hand->之后hand为1

请注意，如果所有对象的参考位都设置为1，则手上的对象将被替换，因为在检查对象后，其参考位设置为0，因此第二次检查对象时，该位将为0

编辑：

以下是@PeterLawrey代码的扩展/调整版本：

private final Object[] objects= new Object[5]; 
private final boolean[] referenced = new boolean[5]; //boolean for simplicity
private int clock = 0;

public Object getOrCache(Object obj) {
   for(int i = 0; i < objects.length; ++i) {
     if (obj.equals(objects[i])) {
       referenced[i] = true; //object has been referenced, note that this is for simplicity and could be optimized
       return obj;
     }
   }

   //loop over the entries until there is a non-referenced one
   //reference flags are removed in the process
   while( referenced[clock] ) {
     referenced[clock] = false;
     clock = (clock + 1) % objects.length; //for clarity
   }

   //replace the object at the current clock position and increment clock
   objects[clock] = obj;
   referenced[clock] = true;
   clock = (clock + 1) % objects.length; //for clarity

   return obj;
}

private final Object[]objects=新对象[5]；
私有最终布尔值[]引用=新布尔值[5]//为了简单起见，布尔运算
专用int时钟=0；
公共对象getOrCache（对象obj）{
对于（int i=0；i

是否应该检查引用位，并且仅当对象的引用位为0时才会替换该对象？因此，您将递增

clock

，直到找到一个referenced=0的条目（如果所有元素都已被引用，则该条目可能是第一个元素，因此第一个元素将在第一轮中将其引用位设置为0）。您可以这样做，以执行最近使用最少的伪值。我会编辑。据我所知，这个实现是针对smth的，比如简单的FIFO。我应该实现参考位，对吗？@golgofa我也添加了参考位。你以两种不同的方式递增时钟，我怀疑第一种是不正确的数组没有indexOf方法。@PeterLawrey你说得对，我会修正：）-我太习惯于使用集合而不是数组了，以至于我完全忘了我们这里有一个数组。非常感谢，所有的答案都非常有用。我的英语不是很好，所以，我可以理解英文文章中的所有语法，但有时不能理解整个意思。还有一些问题。我使用Clock来实现Clock Pro缓存替换。Main非常复杂，真正的实现是我在linux内核中见过的。有人试过Java吗？大多数问题都与特殊术语有关：例如，我还没有看到关于什么是常驻和非常驻页面的解释。也没有看到简单的工作实例。

private final Object[] objects= new Object[5]; 
private final boolean[] referenced = new boolean[5]; //boolean for simplicity
private int clock = 0;

public Object getOrCache(Object obj) {
   for(int i = 0; i < objects.length; ++i) {
     if (obj.equals(objects[i])) {
       referenced[i] = true; //object has been referenced, note that this is for simplicity and could be optimized
       return obj;
     }
   }

   //loop over the entries until there is a non-referenced one
   //reference flags are removed in the process
   while( referenced[clock] ) {
     referenced[clock] = false;
     clock = (clock + 1) % objects.length; //for clarity
   }

   //replace the object at the current clock position and increment clock
   objects[clock] = obj;
   referenced[clock] = true;
   clock = (clock + 1) % objects.length; //for clarity

   return obj;
}