标签: happens-before

Java的内存模型基于强制执行规则的“先有先后”关系，但也允许在缓存失效方面优化虚拟机的实现。

例如，在以下情况下：

// thread A
private void method() {
   //code before lock
   synchronized (lockA) {
       //code inside
   }
}

// thread B
private void method2() {
   //code before lock
   synchronized (lockA) {
       //code inside
   }
}

// thread B
private void method3() {
   //code before lock
   synchronized (lockB) {
       //code inside
   }
}

如果线程A调用method()而线程B试图在lockA内部获取method2()，则同步lockA将要求线程B在释放其锁之前，观察线程A对所有变量所做的所有更改，甚至包括之前在“代码”中更改的变量。锁定”部分。

另一方面，method3()使用另一个锁并且不强制发生关系之前的事件。这为优化创造了机会。

我的问题是虚拟机如何实现那些复杂的语义？是否在不需要缓存时避免完全刷新缓存？

它如何跟踪在哪个点哪个线程更改了哪个变量，从而仅从内存加载所需的缓存行？

我正在尝试一些C#代码的Java端口,我很惊讶地看到javac 1.8.0_60 getfield每次访问一个对象字段时都会发出操作码.

这是Java代码:

public class BigInteger
{
    private int[] bits;
    private int sign;

    //...

    public byte[] ToByteArray()
    {
        if (sign == 0)
        {
            return new byte[] { 0 };
        }

        byte highByte;
        int nonZeroDwordIndex = 0;
        int highDword;
        if (bits == null)
        {
            highByte = (byte)((sign < 0) ? 0xff : 0x00);
            highDword = sign;
        }
        else if (sign == -1)
        {
            highByte = (byte)0xff;
            assert bits.length > 0;
            assert bits[bits.length - 1] != 0;
            while …

我正在阅读"了解JVM高级功能和最佳实践",其中包含一个代码段,用于解释java中的先发制人规则.我不明白.代码如下:

private int value = 0;
//executed by Thread A
public void setValue(int value){
    this.value = value;
}
//executed by Thread B
public void getValue(){
    return value;
}

假设A线程B在代码中的线程之前启动.我可以理解,我们不知道getValue()线程B 返回的结果,因为它不是线程安全的.但是,这本书说,如果添加的同步关键字的功能setValue()和getValue(),那么就没有存在线程安全问题和方法getValue()将返回正确的值.这本书解释说,因为synchronized符合先前发生的规则.所以我在下面的代码中有两个问题.

public class VolatileDemo3 {
    private volatile int value = 0;
    public static void main(String[] args) {
        VolatileDemo3 v = new VolatileDemo3();
        Thread A = new Thread(v.new Test1());// Thread A
        Thread B = new Thread(v.new Test2());//Thread B …

考虑请求 - 响应协议.

我们生成一个线程来执行一个select()循环,用于读取和写入已接受的非阻塞SocketChannel.这可能看起来像

while (!isStopped()) {
    selector.select();
    Iterator<SelectionKey> selectedKeys = selector.selectedKeys().iterator();

    while (selectedKeys.hasNext()) {
        SelectionKey selectedKey = selectedKeys.next();
        selectedKeys.remove();
        Context context = (Context) selectedKey.attachment();
        if (selectedKey.isReadable()) {
            context.readRequest();
        } else /* if (selectedKey.isWritable()) */ {
            context.writeResponse();
        }
    }
}

where Context只是一个容器,用于相应的SocketChannel,一个缓冲区和逻辑来读入它并从中写入.在readRequest可能看起来像

public void readRequest() {
    // read all content
    socketChannel.read(requestBuffer);
    // not interested anymore
    selectionKey.interestOps(0);
    executorService.submit(() -> {
        // handle request with request buffer and prepare response
        responseBuffer.put(/* some response …

我目前正在攻读并发编程考试并且不明白为什么这个程序的输出是43.为什么x = y + 1之前执行t.start()？我还应该解释在我使用的规则之前发生了什么.

如果我理解程序顺序规则(一个线程中的每个动作发生 - 在该程序顺序后面的那个线程中的每个动作之前)t.start()都必须在执行之前执行,x = y + 1以便线程t复制变量x1.

public class HappensBefore {

static int x = 0;
static int y = 42;

public static void main(String[] args) {
    x = 1;
    Thread t = new Thread() {
        public void run() {
            y = x;
            System.out.println(y);
        };
    };
    t.start();
    x = y + 1;
}

-Thread 1-                
y.store (20, memory_order_release); 
x.store (10, memory_order_release);

-Thread 2-
if (x.load(memory_order_acquire) == 10) {
  assert (y.load(memory_order_acquire) == 20);
  y.store (10, memory_order_release)
}

-Thread 3-
if (y.load(memory_order_acquire) == 10) {
  assert (x.load(memory_order_acquire) == 10);
}

GCC Atomic Wiki的 “总体摘要”段落说？上面的代码assert(x.load(memory_order_acquire))可能会失败。但是我不明白为什么？

我的理解是？

1. 线程3 由于获取障碍而无法LoadLoad重新排序。
2. 由于发布障碍，Thread1无法对StoreStore重新排序。
3. 当Thread2读取（x）-> 10时，必须将x从存储缓冲区刷新到Thread1中的缓存，因此每个线程都知道x的值已更改，例如使缓存行无效。
4. Thread3使用Acquire屏障，因此可以看到x（10）。