在Java中，如果每个线程写入单独的单元空间，是否需要同步对数组的写入访问？

Question

如果每个线程写入单独的单元空间，是否需要同步 Java 中数组的写入访问？

编辑：具体来说，该数组是原始数组或不可变对象数组。前任。 int 数组或 String 数组。

Answer 1

一般来说，是的。尝试使用矢量代替。

Answer 2

我正要添加一个与此主题相关的问题。我做了一个测试，在访问数组时强制争用。两者都控制协调访问或使用非同步读取-修改-写入操作（如索引）。

当使用索引时——一些计数器> 1（全部应该为1，否则互斥破坏）

public class App {


static int threads = 1000;
static int maxIndex = 1000;

public static void main(String[] args)
{
    try {
        testThreads();
    } catch (InterruptedException ex) {
        Logger.getLogger(App.class.getName()).log(Level.SEVERE, null, ex);
    }
    return;

}

public static void testThreads() throws InterruptedException {

    AtomicInteger[] ids = new AtomicInteger[maxIndex];
    for (int i = 0; i < maxIndex; i++) {
        ids[i] = new AtomicInteger(0);  
    }
    Executor exec = Executors.newFixedThreadPool(threads);
    AtomicInteger index = new AtomicInteger(maxIndex);
    final CountDownLatch startGate = new CountDownLatch(1);
    final CountDownLatch endGate = new CountDownLatch(threads);

    for (int i = 0; i < threads; i++) {
        exec.execute(new Runnable() {

            @Override
            public void run() {
                try {
                    startGate.await();
                    try {
                        int i = maxIndex;
                        while (i > 0) {
                            /** 
                             * Interchanging this lines force or avoid collisions. 
                             */
                         // i = --maxIndex;
                            i = index.decrementAndGet();
                            ids[i].incrementAndGet(); 
                        }
                    } catch(Exception ignored) {
                        System.out.println(ignored);
                    } finally {
                        endGate.countDown();
                    }
                } catch (InterruptedException ignored) {
                }
            }
        });
    }
    startGate.countDown();
    endGate.await();
    System.out.println(new ArrayList(Arrays.asList(ids)));
}
}

Answer 3

不要直接写入共享资源。你会让多线程程序的性能比单线程程序的性能更差。当缓存在块中被获取和失效时，缓存中的垃圾效应。如果您想了解更多信息，请看这个演讲。使用 volatile 和 Synchronize 比什么都不使用要好，但仍然很慢。

https://www.youtube.com/watch?v=VCattsfHR4o

Answer 4

并发兴趣邮件列表提出了类似的问题 - “原子字节[]操作？”。

大卫·霍姆斯说：

读/写数组的不同区域应该像
访问独立数组。这就是“不撕词”
保证。不管VM是如何实现阵列的
必须确保这适用于基本数组访问。

正如我所说，尚不清楚 arraycopy 的本机版本是否获得
参与其中。

Answer 5

您可以执行您所要求的操作，更新每个索引所保存的内容，但不能保证读取索引中数据的其他线程正在看到当前数据。

Java 中有一个名为 易失性 的关键字，它标记实例和类变量，以便 JVM 知道这些值预计会发生变化，并且不会进行任何读取缓存优化，因为读取线程可能会过时数据。由于您无法将数组索引内容标记为易失性，因此其他读取器可能会获取过时的数据。

在 Java 中使用原始数组仅在非常特定的场景中才是好的做法。您的情况可能是其中一种情况，但我无法从问题中看出，因此我建议您查看 java.util.concurrent 特别位于 CopyOnWriteArrayList 和 CopyOnWriteArraySet 如果您不想重复。

由于某种原因，它们现在已成为标准库的一部分，如果您正在进行大量线程和数据共享，您应该尽可能熟悉java.util.concurrent。

Answer 6

相同的线程是否也在读取该值。如果是这样那就没问题了。如果没有，那么您需要担心其他线程是否看到最新的值。这通常是通过关键工作 volatile 或通过原子变量来处理的。

For example if you have an int [] intArray with three elements.

thread 1 updates intArray[0]=<new value>
thread 2 updates intArray[1]=<new value>
thread 3 updates intArray[2]=<new value>

如果这些线程也用于读取值那么你没问题，但如果一个新线程 -->线程 4 尝试读取值，则不能保证它会看到最新的分配。

如果你使用 AtomicIntegerArray、AtomicLongArray 或 AtomicReferenceArray 就可以了

Answer 7

如果您希望其他线程始终能够看到您写入的最后一个值，则通常需要同步。但我可能会在某些情况下，例如，预先计算一个非常昂贵的 long[] （其中每个条目都会占用大量 CPU），并且您会从多个线程执行此操作，知道这些线程中的任何两个都不得写入同一单元。然后，一旦所有线程完成，您将使用同步一次，以确保每个后续读取都会看到正确的值。类似的事情。

请注意，如果您不想自己处理同步问题，您可能需要研究像 AtomicLongArray 这样的类。作为一个额外的好处，像 AtomicLongArray 这样的类可能由不可能在 100% Java 中重新创建的实现支持。

Answer 8

这不是一个简单的“是或否”问题。需要考虑的一些事情：

• 您的问题意味着您正在数组中存储原始类型（或引用）。对存储在数组中的对象执行复杂的操作可能需要同步。
• 在没有同步的情况下更改 long 或 double 值是不安全的
• ，即使您存储的基元不 double 或 long，由于缓存，其他线程可能无法立即看到更改的值（导致读取过时）

Answer 9

如果读访问也以相同的方式分区，则不需要根据 bkail 的链接进行同步。

但是，如果线程读取彼此的写入，则仍然需要有内存屏障强制缓存内容同步。否则，threadys 可能会得到不一致的读取结果。

Answer 10

不，不需要同步。

它在 JLS §17.6 单词撕裂中定义：

Java 虚拟机的一个实现考虑因素是每个字段和数组元素都被认为是不同的；对一个字段或元素的更新不得与任何其他字段或元素的读取或更新交互。特别是，分别更新字节数组相邻元素的两个线程不得干扰或交互，并且不需要同步来确保顺序一致性。