Java 并发性：先发生后保证

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

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

让我们看一个例子。

此块：

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

可以重新排序到此块：

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

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

var x = i+j;

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

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

想象一下这样一种情况：一个线程执行代码块依赖于另一个线程的执行结果。这是发生在之前的关系的情况。我们有两个事件，结果应该是一个事件，就好像一个事件发生在另一个事件之前，而不考虑重新排序。

Java 有一个先发生后保证。

规则

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

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

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

3. 在已启动线程中的任何操作之前，都会对线程进行调用。start()

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

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

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

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

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

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

1
public class HappensBeforeMonitor {
2
 
3
    private int x = 0;
4
    private int y = 0;
5
     
6
    public void doXY() {
7
        synchronized(this) {
8
            x = 1;
9
            y = 2;
10
        }
11
    }
12
 
13
 
14
}

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

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

1
public class HappensBeforeVolatile {
2
 
3
    private volatile int amount;
4
 
5
 
6
    public void update(int newAmount) {
7
        amount =  newAmount;
8
    }
9
 
10
    public void printAmount() {
11
        System.out.println(amount);
12
    }
13
 
14
}

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

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

任何重新排序都不会影响线程上的操作和线程启动的操作之间的顺序。线程内的所有操作都将在线程启动后发生。

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

线程调用加入 。内部操作将在连接之前进行。当加入调用完成时，更改将对 可见。bthread athread a thread bThread athread b

1
private int x = 0;
2
private int y = 1;
3
 
4
public void calculate() throws InterruptedException {
5
...
6
    final Thread a = new Thread(() -> {
7
        y = x*y;
8
    });
9
    Thread b = new Thread(() -> {
10
 
11
        try {
12
            a.join();
13
            System.out.println(y);
14
        } catch (InterruptedException e) {
15
            throw new RuntimeException(e);
16
        }
17
    });
18
 
19
    a.start();
20
    b.start();
21
    b.join();
22
...
23
}

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

以这个普通类为例：

1
public class HappensBeforeConstructor {
2
 
3
    private final  int x;
4
    private final  int y;
5
    public HappensBeforeConstructor(int a ,int b) {
6
        x = a;
7
        y = b;
8
    }
9
 
10
}

如果我们考虑一下，实例化的对象会继承 Java 中的每个对象。如果扩展 of 不是隐式的，则类将如下所示：Object.classObject

public class HappensBeforeConstructor extends Object {
2
 
3
    private final  int x;
4
    private final  int y;
5
    public HappensBeforeConstructor(int a ,int b) {
6
        super();
7
        x = a;
8
        y = b;
9
    }
10
 
11
}

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