happensbefore java 原则简述

原创

mob64ca12e732bb 2024-09-04 03:36:09 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12e732bb的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java中的Happens-Before原则详解

在并发编程中，多线程之间的执行顺序和数据一致性是至关重要的。为了保证正确性，Java通过“happens-before”原则来定义线程间的可见性和顺序。本文将围绕这一原则进行详细探讨，并通过代码示例加以说明。

什么是Happens-Before原则？

“Happens-before”是指在多线程环境中，当一个操作发生在另一个操作之前时，前者的影响在后者能看到的范围内。Java内存模型提供了一系列规则来定义happens-before关系。通过遵循这些规则，可以确保多线程程序的正确性，从而避免数据不一致和竞争条件。

以下是一些常见的happens-before规则：

程序顺序规则：在同一个线程中，代码的执行顺序是严格的。即前面的操作总会影响后面的操作。
监视器锁规则：对一个监视器的解锁操作happens-before对该监视器的锁定操作。
线程启动规则：一个线程的start()方法happens-before它所启动的线程的任何操作。
线程终止规则：线程的所有操作happens-before其他线程成功返回该线程的join()方法。

示例代码

下面是一个简单的示例，演示了happens-before原则在实际代码中的应用。

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final Count: " + counter.getCount());
    }
}

代码分析

在上述代码中，我们使用了监视器锁（synchronized）来确保对共享变量count的访问是安全的。通过synchronized关键字，我们确保对count的增量操作和读取操作之间遵循了happens-before关系。具体表现为：

increment()方法中的操作在同一线程中的链式调用会维持顺序。
由于对同一监视器的锁定和解锁操作，线程对count的修改是可见的。

序列图

为了更直观地理解happens-before原则，我们来看一下下面的序列图，这里展示了两个线程是如何交互的：

sequenceDiagram
    participant T1 as Thread 1
    participant T2 as Thread 2
    participant C as Counter

    T1->>C: increment()
    C->>C: count++
    T1-->>T1: done
    T2->>C: increment()
    C->>C: count++
    T2-->>T2: done
    T1->>T2: join()
    T2->>T1: done join
    T1-->>T1: Final Count

序列图中，两个线程都调用了increment()方法，确保了对count的访问不会导致数据冲突，并在join()的调用中确保主线程在两个子线程完成后才能继续执行。

旅行图

下面的旅行图展示了在执行happens-before原则下，线程在时间上的执行过程：

journey
    title Java Happens-Before原则执行过程
    section Thread 1
      Start increment: 5: Thread 1 calls increment()
      Count increment: 3: Incremented count
      End increment: 4: Thread 1 ends increment()
    section Thread 2
      Start increment: 5: Thread 2 calls increment()
      Count increment: 3: Incremented count
      End increment: 4: Thread 2 ends increment()
    section Main Thread
      Wait for join: 5: Main thread waits
      Print count: 3: Print final count

在旅行图中，我们可以看到每个线程的状态和操作顺序，进而理解happens-before原则如何确保每个操作的可见性。