Java中的数组是线程安全的吗？

Question

一个线程从数组的一个索引读取，而另一个线程写入数组的另一个索引，是否存在任何并发问题，只要索引不同？

例如（这个例子不一定推荐实际使用，只是为了说明我的观点）

 class Test1
 {
     static final private int N = 4096;
     final private int[] x = new int[N];
     final private AtomicInteger nwritten = new AtomicInteger(0);
     // invariant: 
     // all values x[i] where 0 <= i < nwritten.get() are immutable

     // read() is not synchronized since we want it to be fast
     int read(int index) {
         if (index >= nwritten.get())
             throw new IllegalArgumentException();
         return x[index];
     }
     // write() is synchronized to handle multiple writers
     // (using compare-and-set techniques to avoid blocking algorithms
     // is nontrivial)
     synchronized void write(int x_i) {
         int index = nwriting.get();
         if (index >= N)
             throw SomeExceptionThatIndicatesArrayIsFull();
         x[index] = x_i;
         // from this point forward, x[index] is fixed in stone
         nwriting.set(index+1);
     }     
 }

编辑： 批评这个例子不是我的问题，我实际上只是想知道数组访问一个索引，同时访问另一个索引，是否会造成并发问题，想不出简单的例子。

Answer 1

虽然您不会像您提到的那样通过更改数组来获得无效状态，但是当两个线程在没有同步的情况下查看非易失性整数时，您将遇到同样的问题（请参阅Memory Consistency Errors 上的 Java 教程中的部分） .基本上，问题是线程 1 可能会在空间 i 中写入一个值，但不能保证线程 2 何时（或是否）会看到更改。

java.util.concurrent.atomic.AtomicIntegerArray 类做你想做的事。

Answer 2

这个例子有很多与散文问题不同的东西。

该问题的答案是数组的不同元素是独立访问的，因此如果两个线程更改不同的元素，则不需要同步。

但是，Java 内存模型不保证（据我所知）一个线程写入的值将对另一个线程可见，除非您同步访问。

根据您真正想要完成的任务，java.util.concurrent 可能已经有一个可以为您完成任务的课程。如果没有，我仍然建议您查看ConcurrentHashMap 的源代码，因为您的代码似乎在做与管理哈希表相同的事情。

Answer 3

我不确定是否只同步 write 方法，而不同步 read 方法是否可行。并不是所有的后果是什么，但至少它可能导致read 方法返回一些刚刚被write 覆盖的值。

Answer 4

是的，因为糟糕的缓存交错仍然可能发生在多 CPU/核心环境中。有几种方法可以避免它：

• 使用 Unsafe Sun 私有库以原子方式设置数组中的元素（或 Java7 中的 jsr166y 添加功能
• 使用 AtomicXYZ[] 数组
• 使用带有一个 volatile 字段的自定义对象并拥有该对象的数组。
• 在您的算法中改用 jsr166y 附录的 ParallelArray

Answer 5

由于 read() 未同步，您可能会遇到以下情况：

Thread A enters write() method
Thread A writes to nwriting = 0;
Thread B reads from nwriting =0;
Thread A increments nwriting. nwriting=1
Thread A exits write();

既然你想保证你的变量地址永远不会冲突，那么像（折扣数组索引问题）这样的东西呢：

int i;
synchronized int curr(){ return i; }
synchronized int next(){ return ++i;}

int read( ) {
         return values[curr()];
     }

void write(int x){
   values[next()]=x;
}