通常，当我们编写代码时，我们会假设代码的执行顺序与编写的顺序相同。事实并非如此，因为出于优化目的，语句的重新排序发生在编译时或运行时。

Java 并发性：先发生保证_开发语言

    无论线程何时运行程序，结果都应该是所有操作都按照它们在程序中出现的顺序发生。单线程程序的执行应遵循 as-if-serial 语义。只要保证结果与程序的结果相同（如果语句已按顺序执行），就可以引入优化和重新排序。

让我们看一个例子。

此块：

var i = 0;
var j = 1;
j--;

可以重新排序到此块：

var j = 1;
j--;
var i = 0;

我们可以根据前几个区块的结果添加额外的分配。

var x = i+j;

    无论发生了何种重新排序，结果都应该像程序的每个语句都是按顺序运行的一样。

    从单线程的角度来看，我们被覆盖了;但是，当多个线程对这样的块进行操作时，会出现各种问题。线程操作的效果不会以可预测的方式对其他线程可见。

    想象一下这样一个场景：一个线程对代码块的执行取决于另一个线程的执行结果。这是 Happened-Before 关系的情况。我们有两个事件，结果应该是 1 个事件发生在另一个事件之前，而不管是否重新排序。

Java 具有先发生保证。

规则

我们可以查看文档并查看使保证成为可能的规则。

  1. 监视器上的解锁发生在该监视器上的每个后续锁定之前。
  2. 对字段的写入发生在每次后续读取该字段之前。volatile
  3. 对线程的调用 - 在启动的线程中的任何操作之前发生。start()
  4. 线程中的所有操作都发生在任何其他线程成功从该线程返回之前。join()
  5. 任何对象的默认初始化都发生在程序的任何其他操作（默认写入除外）之前。

它们是不言自明的。让我们检查一下他们的一些代码。

1. 显示器上的解锁发生 - 在该显示器上的每次后续锁定之前。

Java 中的每个对象都有一个内部锁。当我们使用 synchronized 时，我们使用对象的锁。

假设我们有一个类和一些方法，并且我们使用对象的锁：

public class HappensBeforeMonitor {
 
    private int x = 0;
    private int y = 0;
     
    public void doXY() {
        synchronized(this) {
            x = 1;
            y = 2;
        }
    }
 
 
}

    提供了线程调用 .在获取锁之前，无法解锁对象具有的锁。正如我们之前看到的，synchronized 方法包装了 lock 和 unlock 语句中包含的代码。任何重新排序优化都不应更改 lock 操作和 unlock 操作的顺序。doXY()

2. 对 volatile 字段的写入发生在该字段的每次后续读取之前。

public class HappensBeforeVolatile {
 
    private volatile int amount;
 
 
    public void update(int newAmount) {
        amount =  newAmount;
    }
 
    public void printAmount() {
        System.out.println(amount);
    }
 
}

    假设调用 update 然后调用以打印金额。读取将在写入之后进行。写入会将值写入主内存。结果是从 中设置值。thread athread bthread bthread a

3. 在线程上调用 start（） 发生在启动的线程中的任何操作之前。

    没有重新排序将影响线程上的操作与线程启动的操作之间的顺序。线程内的所有操作都将在线程启动后进行。

4. 线程中的所有操作都发生 - 在任何其他线程从该线程上的 join（） 成功返回之前。

    线程调用 join on 。内部操作将在 join 之前进行。当加入呼叫结束时，更改将对 可见。bthread athread a thread bThread athread b

private int x = 0;
private int y = 1;
 
public void calculate() throws InterruptedException {
...
    final Thread a = new Thread(() -> {
        y = x*y;
    });
    Thread b = new Thread(() -> {
 
        try {
            a.join();
            System.out.println(y);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    });
 
    a.start();
    b.start();
    b.join();
...
}

5. 任何对象的默认初始化发生在程序的任何其他操作（默认写入除外）之前。

以这个 plain 类为例：

public class HappensBeforeConstructor {
 
    private final  int x;
    private final  int y;
    public HappensBeforeConstructor(int a ,int b) {       
        x = a;
        y = b;
    }
 
}

    如果我们仔细想想，实例化的对象就像 Java 中的每个对象一样继承了 the。如果 的扩展名不是隐式的，则类将如下所示：Object.classObject

爪哇岛

public class HappensBeforeConstructor extends Object {
 
    private final  int x;
    private final  int y;
    public HappensBeforeConstructor(int a ,int b) {
        super();
        x = a;
        y = b;
    }
 
}

    该方法实例化对象。这是默认初始化，构造函数中的其他操作都不会被重新排序并在它之前发生。super();