并发编程之并发理论篇--as-if-serial规则和happens-before规则的区别

目录

as-if-serial规则

happens-before规则

happens-before定义

具体的六条规则

代码示例

as-if-serial规则

happens-before规则

as-if-serial与happens-before的区别

---

as-if-serial规则

as-if-serial规则确保了单线程程序的执行结果不会被改变，即在单线程环境下，程序的执行顺序应当按照代码的顺序来执行，而不会受到编译器和处理器的重排序的影响。

具体来说，as-if-serial规则包括以下两个方面：

• 编译器重排序：编译器在不改变单线程程序的语义的前提下，可以对指令顺序进行重排，以优化程序性能。但是，编译器不能改变存在数据依赖关系的操作的执行顺序，因为这样可能会改变程序的执行结果。
• 处理器重排序：处理器在执行指令时，也可以对其进行重排序。类似地，处理器不能改变存在数据依赖关系的操作的执行顺序。

总的来说，as-if-serial规则保证了单线程程序在多线程环境下的正确性。它确保了在不改变程序语义的情况下，编译器和处理器对指令的重排序不会影响单线程程序的执行结果。这样可以提高程序的性能，同时保持程序的正确性。

happens-before规则

happens-before规则是Java内存模型（JMM）为并发编程提供的六条规则，用于推断跨线程的内存可见性问题。这些规则可以帮助程序员理解操作之间的执行顺序，并通过happens-before关系来保证内存可见性。

happens-before定义

happens-before关系最初由Leslie Lamport在他的论文《Time, Clocks, and the Ordering of Events in a Distributed System》中提出，并被Java内存模型（JMM）采用来描述并发编程中操作之间的执行顺序。

根据JMM的规定，如果一个操作A happens-before另一个操作B，那么操作A的执行结果对操作B可见，并且操作A的执行顺序在操作B之前。这个关系可以是在同一个线程内的两个操作，也可以是在不同线程中的两个操作。

happens-before关系的主要作用是为程序员提供跨线程的内存可见性保证。具体来说，如果操作A和操作B之间存在happens-before关系，尽管它们可能在不同的线程中执行，JMM保证操作A的结果对操作B可见。

需要注意的是，happens-before关系并不意味着Java平台的具体实现必须按照happens-before关系指定的顺序执行操作。编译器和处理器可以对操作进行重排序，只要重排序后的执行结果与按照happens-before关系执行的结果一致即可。这样做是为了允许编译器和处理器进行优化，同时保持程序的语义正确性。

总结起来，happens-before关系是Java内存模型提供的一种保证机制，用于指定操作之间的执行顺序，以确保内存可见性和程序的语义正确性。

具体的六条规则

1. 程序顺序规则：一个线程中的每个操作在该线程中都是按照顺序执行的，前一个操作的结果对后续操作可见。
2. 监视器锁规则：对一个锁的解锁操作先行发生于随后对该锁的加锁操作。也就是说，释放锁的操作先行发生于获取锁的操作。
3. volatile变量规则：对一个volatile变量的写操作先行发生于随后对该变量的读操作。volatile关键字保证了变量的可见性。
4. 传递性规则：如果操作A先行发生于操作B，并且操作B先行发生于操作C，那么操作A先行发生于操作C。即，如果A happens-before B，B happens-before C，则A happens-before C。
5. start()规则：如果线程A执行了线程B的start()操作（启动线程B），则线程A中的ThreadB.start()操作先行发生于线程B中的任何操作。
6. join()规则：如果线程A执行了线程B的join()操作并成功返回，那么线程B中的任何操作都先行发生于线程A从join()操作成功返回。
7. 线程中断规则：对线程 interrupt() 方法的调用 happens-before 于被中断线程的响应操作。
8. 对象 finalize 规则：一个对象的初始化操作 happens-before 于该对象 finalize() 方法的开始。

代码示例

as-if-serial规则和happens-before规则是Java内存模型提供的两个重要的约束原则，下面以代码示例的方式来说明它们的作用：

as-if-serial规则

as-if-serial规则是Java内存模型提供的一个优化原则，指的是编译器和处理器可以对操作进行重排序，只要不改变程序的执行结果。下面是一段示例代码：

public class AsIfSerialExample {
    private int x = 0;
    private boolean flag = false;

    public void write() {
        x = 1;
        flag = true;
    }

    public void read() {
        if (flag) {
            int y = x + 1;
            System.out.println("y = " + y);
        }
    }
}

上述代码中，write()方法会先写入x的值为1，然后再将flag标记为true；read()方法会检查flag的值，如果为true，则读取x的值并计算y = x + 1。

根据as-if-serial规则，编译器和处理器可以对write()方法和read()方法中的操作进行重排序，如下所示：

public void write() {
    flag = true;
    x = 1;
}

public void read() {
    if (flag) {
        int y = x + 1;
        System.out.println("y = " + y);
    }
}

从程序执行结果来看，以上两种代码是等价的，因为它们都会输出y的值为2，符合as-if-serial规则的要求。注意，这种重排序只有在不影响程序执行结果的情况下才能进行。

happens-before规则

happens-before规则是Java内存模型提供的一个约束原则，用于指定操作之间的执行顺序，并为程序员提供跨线程的内存可见性保证。下面是一段示例代码：

public class HappensBeforeExample {
    private int x = 0;

    public void write() {
        x = 1;
    }

    public void read() {
        if (x == 1) {
            System.out.println("x = " + x);
        }
    }
}

上述代码中，write()方法会将x的值设置为1；read()方法会检查x的值是否为1，并输出x的值。

根据happens-before规则，如果write()操作happens-before read()操作，则x的值为1将对read()方法可见。因此，可以使用volatile关键字来保证happens-before关系，如下所示：

public class HappensBeforeExample {
    private volatile int x = 0;

    public void write() {
        x = 1;
    }

    public void read() {
        if (x == 1) {
            System.out.println("x = " + x);
        }
    }
}

在这种情况下，无论x和read()方法在哪两个线程中执行，happens-before规则都保证了x的值为1对read()方法的可见性。

as-if-serial与happens-before的区别

as-if-serial规则和happens-before规则是Java内存模型中的两个不同的概念，它们有以下几个区别：

1、作用范围：

• as-if-serial规则：该规则是编译器和处理器的优化原则，它允许对操作进行重排序，只要不改变程序的执行结果。它的作用范围是在单个线程内部。
• happens-before规则：该规则是Java内存模型提供的保证机制，用于指定操作之间的执行顺序，并为程序员提供跨线程的内存可见性保证。它的作用范围是在多线程之间。

2、目的：

• as-if-serial规则：它的目的是允许编译器和处理器进行优化，以提高程序的执行效率。重排序可以改变操作的执行顺序，但不能改变程序的语义。
• happens-before规则：它的目的是确保多线程环境下操作的顺序性和可见性，以避免数据竞争和并发错误。happens-before关系确定了操作之间的先后顺序，保证了内存可见性和一致性。

3、用途：

• as-if-serial规则：它提供了一种优化机制，允许编译器和处理器对操作进行重排序，以提高程序的性能。它在编译器和处理器级别起作用，并且不会改变程序的语义。
• happens-before规则：它提供了一种内存可见性保证机制，在多线程编程中非常重要。通过happens-before关系，程序员可以确保操作的执行顺序和对共享数据的修改在不同线程之间正确传递。

总的来说，as-if-serial和happens-before都是为了提高程序执行效率和保证多线程程序的正确性而存在的。as-if-serial规则是编译器和处理器的优化原则，允许对操作进行重排序以提高程序的性能，适用于单线程程序的优化；而happens-before规则是保证多线程环境下操作顺序性和可见性的机制，确保操作执行的先后顺序和对共享数据的修改在不同线程之间正确传递，适用于多线程环境下的同步操作。

下面是一个结合了as-if-serial和happens-before的Java代码示例：

public class Main {
    private static int sharedVariable = 0;
    private static boolean flag = false;

    public static void main(String[] args) {
        Thread writerThread = new Thread(() -> {
            sharedVariable = 1;  // 对共享变量的写操作（W1）
            flag = true;  // 对共享变量的写操作（W2）
        });

        Thread readerThread = new Thread(() -> {
            int localVar = sharedVariable;  // 对共享变量的读操作（R1）
            boolean localFlag = flag;  // 对共享变量的读操作（R2）

            if (localFlag) {  // 先读取flag的值（R3）
                System.out.println("共享变量 = " + localVar);  //输出：共享变量 = 1
            }
        });

        writerThread.start();
        readerThread.start();
    }
}

在该示例中，我们有一个写线程(writerThread)和一个读线程(readerThread)，它们共享一个变量sharedVariable，并通过一个布尔标志flag进行通信。根据happens-before规则，在不使用显式的同步操作的情况下，共享变量的写操作先于读操作，能够保证读线程能够观察到写线程对共享变量的修改。

此外，代码中还涉及到了as-if-serial规则。读线程在进行变量的读操作时，会产生本地变量localVar和localFlag，这种本地变量的引入可以避免编译器对读操作的重排序，因为编译器不能改变程序的语义，它必须保证读操作与写操作在as-if-serial意义下的执行顺序。