挥发性阵列的奇怪行为

Question

我知道这意味着如果你声明一个数组volatile，那么对数组的引用不是数组中的项。

我学习互斥算法，所以我写了一些测试代码：

public class MutualExclusion { 
    static final int N = 10; 
    static final int M = 100000; 

    volatile static int count = 0; 

    public static void main(String[] args) { 
     Thread[] threads = new Thread[N]; 
     for (int i = 0; i < N; i++) { 
      Thread t = new Worker(i); 
      threads[i] = t; 
      t.start(); 
     } 
     for (Thread t: threads) { 
      try { 
       t.join(); 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 
     } 
     if (count != N * M) { 
      System.out.println("count (" + count + ") != N * M (" + String.valueOf(N * M) + ")"); 
     } 
    } 

    static class Worker extends Thread { 
     int id; 
     Worker(int id) { 
      this.id = id; 
     } 

     @Override 
     public void run() { 
      for (int i = 0; i < M; i++) { 
       this.lock(); 
       // critical section 
       count++; 
       if (i % 1000 == 0) { 
        System.out.println(this.getName() + ": " + count); 
       } 
       this.unlock(); 
      } 
     } 


     void lock() { 
      filterLock(); 
     } 

     void unlock() { 
      filterUnlock(); 
     } 

     static volatile int level[] = new int[N]; 
     static volatile int lastToEnter[] = new int[N - 1]; 

     void filterLock() { 
      for (int i = 0; i < (N - 1); i++) { 
       level[this.id] = i; 
       lastToEnter[i] = this.id; 
       outer: 
       while (lastToEnter[i] == this.id) { 
        for (int k = 0; k < N; k++) { 
         if (k != this.id && level[k] >= i) { 
          continue outer; 
         } 
        } 
        break; 
       } 
      } 
     } 

     void filterUnlock() { 
      level[this.id] = -1; 
     } 
    } 
} 

在我的第一个实施滤波算法，我错过了volatile可变level和lastToEnter，这并不奇怪，程序进入一个无限循环。在我添加了缺失的volatile后，该程序可以按预期结束。

正如我在开始时所说的，volatile数组并不意味着数组中的项是易失性的，那么为什么在添加缺少的volatile后程序结束了预期？

当我添加volatile关键字后，我在执行另一个互斥算法时仍然无法正确运行，我问自己这个问题。我有一个小窍门（Java volatile array?），使项目在阵列看起来是挥发性的：（下面的代码可以被粘贴到直接Worker类）

volatile static boolean[] b = new boolean[N]; 
volatile static boolean[] c = new boolean[N]; 
volatile static int k = 0; 

void dijkstraLock() { 
    b[this.id] = false; 
    outer: 
    for (;;) { 
     if (k == this.id) { 
      c[this.id] = false; 

      c = c; // IMPORTANT! the trick 

      for (int i = 0; i < N; i++) { 
       if (i != this.id && !c[i]) { 
        continue outer; 
       } 
      } 
      break; 
     } else { 
      c[this.id] = true; 
      if (b[k]) { 
       k = this.id; 
      } 
     } 
    } 
} 

void dijkstraUnlock() { 
    b[this.id] = true; 
    c[this.id] = true; 
} 

Answer 1

挥发性阵列在Java中不含有挥发性元素 - 但如果你通过数组引用（这是易失性的）访问它们，你将得到一个易失性读取。例如，在上面的代码：

static volatile int lastToEnter[] = new int[N - 1]; 

是易失性的写入，而

lastToEnter[i] = this.id; 

不是。然而，阵列值的评价 - 如：

lastToEnter[i] == this.id 

是挥发性读 - 先读出的基准，其是易失性的阵列，并且只有然后访问第i个元素，以评估其值。

我怀疑这是你的执行成功的原因，一旦数组被声明为volatile。