java - 同步实例而不是 volatile 原语

Question

我有一个对象:

class Data{
   int a;
   int b;
   AtomicIntegerArray c = new AtomicIntegerArray(10000);   
}

该对象在以下场景中被线程 A 和 B 使用:

A 创建一个 Data(现在称为“数据”)

A 将数据发送到队列。

B 从队列中读取，获取数据。

B 更新数据字段并向 A 发出数据已处理完毕的信号。

B sleep 了。

A 开始处理数据字段。

现在，到目前为止我为确保内存可见性所做的事情是:

 class Data{
   volatile int a;
   volatile int b;
   volatile AtomicIntegerArray c = new AtomicIntegerArray(10000);   
}

这可行，但让我担心。当线程A取回数据时，它只需要在开始时同步一次内存，而不是每次触及字段时都同步一次。我想我可以通过简单地让 A 做到这一点来实现这一目标:

synchronized(data){}

一旦它知道数据已更新，则使用 Data 的第一个实现。这样我只进行一次昂贵的内存同步。

我说得对吗？我是否还需要确保线程 B 在“移交给”线程 A 之前同步数据？

请记住，我只对内存同步/可见性感兴趣，没有锁定机制，也不关心线程之间的信号发送。我已经涵盖了。

信号:

class A implements callback{
    private volatile boolean dataProcessed;
    private final Data data = new Data();

    @Override
    public void dataHasBeenProcessed(){
         dataProcessed = true;
    } 

    void someMethod(){
       dataProcessed = false;
       threadB.processData(data, this);
       while(!dataProcessed)
          ...sleep;
       data.workOnFields();

}

因此，A 将数据发送给 B，然后在处理数据时轮询 B 在回调方法中设置的 volatile boolean 值。

Answer 1

TL;DR您根本不需要 volatile 或同步。

线程 A 和 B 永远不会同时接触对象，因此只要它们之间的切换建立了发生在边界，它们将始终看到最新的数据。

例如，如果队列是 BlockingQueue ，你得到这个保证:

Memory consistency effects: As with other concurrent collections, actions in a thread prior to placing an object into a BlockingQueue happen-before actions subsequent to the access or removal of that element from the BlockingQueue in another thread.

因此，只要队列是 BlockingQueue，而不是通用 Queue ，从线程 A 到线程 B 的切换是安全的。

如果从线程 B 返回到线程 A 的信号正在使用例如一个CountDownLatch ，你得到这个保证:

Memory consistency effects: Until the count reaches zero, actions in a thread prior to calling countDown() happen-before actions following a successful return from a corresponding await() in another thread.

因此从线程 B 切换回线程 A 也是安全的。

摘要:

• 线程 A 在发送对象之前所做的一切都发生在线程 B 接收对象之前。

• 线程 B 在发送信号之前所做的一切都发生在线程 A 接收信号之前。

结论:

不需要 volatile 或同步。