Java过滤器算法。为什么使用非易失性变量？

Question

我正在阅读“The Art of Multiprocessor Programming”的第 2 章，我对看起来像这样的过滤算法感到困惑：

class Filter implements Lock {
    int[] level;
    int[] victim;
    public Filter(int n) {
        level = new int[n];
        victim = new int[n]; // use 1..n-1
        for (int i = 0; i < n; i++) {
            level[i] = 0;
        }
    }
    public void lock() {
        int me = ThreadID.get();
        for (int i = 1; i < n; i++) { //attempt level 1
            level[me] = i;
            victim[i] = me;
            // spin while conflicts exist
            while (( ∃ k != me) (level[k] >= i && victim[i] == me)) {};
        }
    }
    public void unlock() {
        int me = ThreadID.get();
        level[me] = 0;
    }
}

我觉得奇怪的是level 和victim 数组不是volatile。在此算法之前，作者提出了不太通用的“彼得森算法”，其中变量设置如下：

private volatile boolean[] flag = new boolean[2];
private volatile int victim;

所以我的问题是为什么在更通用的算法中我们不将level 和victim 指定为volatile？

Answer 1

首先volatile 与final 或static 类似，它仅适用于字段，而不适用于引用的对象。例如

volatile int[] level;

意味着写入level 而不是level[0] 是易失性的。

事实上，在自然 Java 中没有办法做到这一点，这就是为什么 AtomicIntegerArray 使用 Unsafe 来执行 volatile 和线程安全操作。

简而言之，唯一真正的解决方案是使用AtomicIntegerArray（或直接使用Unsafe）。