标签: happens-before

我想澄清一下,在关系与volatile变量一起工作之前会发生什么.我们有以下变量:

public static int i, iDst, vDst;
public static volatile int v;

和线程A:

i = 1;
v = 2;

和线程B:

vDst = v;
iDst = i;

以下语句是否符合Java内存模型(JMM)？如果没有,那么正确的解释是什么？

• i = 1总是发生在以前 v = 2
• v = 2 发生 vDst = v在JMM 之前,只有它实际发生在时间之前
• i = 1 发生 iDst = i在JMM 之前(并且iDst可以预测分配1)如果v = 2实际发生vDst = v在时间之前
• 否则,在i = 1和之间的顺序iDst …

在阅读有关内存一致性错误的Java文档时.我找到了与两个创造事件相关的点 - 在关系之前:

• 当一个语句调用时Thread.start(),与该语句有一个before-before关系的每个语句也与新线程执行的每个语句都有一个before-before关系.新线程可以看到导致创建新线程的代码的影响.

• 当一个线程终止并导致Thread.join()另一个线程返回时,终止
  线程执行的所有语句
  与成功连接后的所有语句都有一个before-before关系.现在,执行连接的线程可以看到线程中代码的效果.

我无法理解他们的意思.如果有人用一个简单的例子解释它会很棒.

以下代码示例显示了一种常见方法，用于演示由于缺少发生之前关系而导致的并发问题。

private static /*volatile*/ boolean running = true;
    
public static void main(String[] args) throws InterruptedException {
    new Thread() {
        @Override
        public void run() {
            while (running) {
                // Do nothing
            }
        }
    }.start();
    Thread.sleep(1000);
    running = false;
}

如果running是volatile，程序保证在大约一秒后终止。但是，如果running不是volatile，则根本无法保证程序终止（因为在running这种情况下没有发生之前关系或保证变量更改的可见性），而这正是我的测试中发生的情况。

根据JLS 17.4.5，人们还可以通过写入和读取另一个volatile变量来强制执行发生前关系running2，如以下代码示例所示。

private static boolean running = true;
private static volatile boolean running2 = true;
    
public static void main(String[] args) throws InterruptedException {
    new Thread() …

我在一个线程中有一个直接的ByteBuffer(off-heap),并使用JMM给我的一种机制安全地将它发布到另一个线程.之前发生的关系是否扩展到ByteBuffer包装的本机(堆外)内存？如果不是,我怎样才能安全地将直接ByteBuffer的内容从一个线程发布到另一个线程？

编辑

这不是重复的多个线程可以在Java中看到直接映射的ByteBuffer上的写入吗？因为

• 我不是在谈论一个mmaped()区域,而是一个普遍的堆外区域
• 我正在安全地发布ByteBuffer
• 我不是同时修改ByteBuffer的内容,我只是将它从一个线程变为另一个线程

编辑2

这不是使Java的ByteBuffer线程安全的选项的重复我不是试图从两个不同的线程同时修改ByteBuffer.我试图从一个线程转到另一个线程并且在由直接ByteBuffer支持的本机内存区域上的语义之前发生.一旦交接,第一个线程将不再修改或读取ByteBuffer.

假设我有一个包装HashMap的类,如下所示:

public final class MyClass{

     private final Map<String, String> map;

     //Called by Thread1
     public MyClass( int size ){
         this.map = new HashMap<String, String>( size );
     }

     //Only ever called by Thread2
     public final String put( String key, String val ){
        return map.put( key, value );
     }

     //Only ever called by Thread2
     public final String get( String key ){
        return map.get( key );
     }

     //Only ever called by Thread2
     public final void printMap(  ){
       //Format and print the contents of the …

问题我已经多年了:在这个伪代码中,

ExecutorService svc = Executors.newFixedThreadPool(3);
svc.submit(new Runnable() { /* code A */ });
svc.shutdown();
if(svc.awaitTermination(...)) {
    // code B

.awaitTermination()没有记录在代码A和B之间发生的事情. 有没有理由不是？

该ExecutorService的和concurrent包的javadoc定义的之前发生完成的任务和工作之间之前,他们已提交,但不执行的任务和代码之间的成功后.awaitTermination()调用.

注意,我不是要求设计批评如何重构我的代码以利用记录的事先关系.我的问题是,在这种情况下,有没有理由说文档没有提及？

(请注意,尽管标题非常贴切,但这并不是22665198的重复.)

我有这个类,我在那里使用它们来缓存实例并克隆它们(数据是可变的).

我想知道我是否可以面对这个重新排序的问题.

我已经看过这个答案和JLS,但我仍然没有信心.

public class DataWrapper {
    private static final ConcurrentMap<String, DataWrapper> map = new ConcurrentHashMap<>();
    private Data data;
    private String name;

    public static DataWrapper getInstance(String name) {
        DataWrapper instance = map.get(name);
        if (instance == null) {
            instance = new DataWrapper(name);
        }
        return instance.cloneInstance();
    }

    private DataWrapper(String name) {
        this.name = name;
        this.data = loadData(name);  // A heavy method
        map.put(name, this);  // I know
    }

    private DataWrapper cloneInstance() {
        return new DataWrapper(this);
    }

    private DataWrapper(DataWrapper that) {
        this.name …

众所周知,如果我们有一些对象引用并且此引用具有final字段 - 我们将看到来自final字段的所有可到达字段(至少在构造函数完成时)

例1:

class Foo{
    private final Map map;
     Foo(){
         map = new HashMap();
         map.put(1,"object");
     }

     public void bar(){
       System.out.println(map.get(1));
     }
}

正如我在这种情况下所做的那样,我们保证bar()方法总是输出object因为:
1.我列出了完整的类代码,Foo并且map是final;
2.如果某个线程会看到引用Foo和引用!= null,那么我们保证从最终map引用值可以到达的是实际的.

我也是这么认为的

例2:

class Foo {
    private final Map map;
    private Map nonFinalMap;

    Foo() {
        nonFinalMap = new HashMap();
        nonFinalMap.put(2, "ololo");
        map = new HashMap();
        map.put(1, "object");
    }

    public void bar() {
        System.out.println(map.get(1));
    }

    public void bar2() {
        System.out.println(nonFinalMap.get(2));
    }
}

在这里,我们对bar() …

在C ++草案标准中多次使用了“在……之前发生”一词。

例如：终止 [basic.start.term] / 5

如果在调用std？::？atexit之前强烈完成了具有静态存储持续时间的对象的初始化（请参见[support.start.term]），则对该函数的调用将传递给std？::？atexit。在调用对象的析构函数之前进行排序。如果对std？::？atexit的调用很强地发生在具有静态存储持续时间的对象的初始化完成之前，则在传递给std？::？atexit的函数的调用之前对对象的析构函数的调用进行排序。 。如果对std？::？atexit的调用在另一次对std？::？atexit的调用之前强烈发生，则传递给第二个std？::？atexit调用的函数的调用将在传递给函数的函数的调用之前按顺序进行。第一个std？::？atexit调用。

并在 数据竞赛 [intro.races] / 12中定义

评估A发生在评估D之前，如果发生以下情况之一

（12.1）A在D之前排序，或

（12.2）A与D同步，并且A和D都是顺序​​一致的原子操作（[atomics.order]），或者

（12.3）对B和C进行求值，使得A在B之前排序，B恰好在C之前发生，而C在D之前排序，或者

（12.4）有一个评估B，使得A强烈发生在B之前，而B强烈发生在D之前。

[注意：非正式地，如果A强烈地发生在B之前，那么在所有情况下A似乎都在B之前被评估。强烈发生在排除消耗操作之前。—尾注]

为什么引入“强烈发生”？直觉上，它与“之前发生的事情”有什么区别和关系？

注释中的“在所有情况下A似乎都在B之前被评估”是什么意思？

（注意：此问题的动机是Peter Cordes在此答案下的评论。）

标准报价附加草案（感谢Peter Cordes）

有序性和一致性[atomics.order] / 4