Java内存模型中的可见性 - 摩柯技术社区

Java内存模型中的可见性基础概念

在Java多线程编程中，可见性是一个非常重要的概念，它直接关系到多个线程之间共享数据的一致性。Java内存模型（Java Memory Model，JMM）定义了Java程序中各种变量（线程共享变量）的访问规则，以及在JVM中将变量存储到内存和从内存中取出变量这样的底层细节。

共享变量与线程工作内存

共享变量：在Java中，实例字段、静态字段和构成数组对象的元素存储在堆内存中，这些变量可以被多个线程所访问，我们称它们为共享变量。例如：

public class VisibilityExample {
    private static int sharedVariable = 0;

    public static void main(String[] args) {
        // 这里的sharedVariable就是共享变量
    }
}

线程工作内存：每个线程都有自己独立的工作内存，线程对共享变量的所有操作都必须在工作内存中进行，而不能直接读写主内存中的变量。线程工作内存中保存了该线程使用到的共享变量的副本。当一个线程修改了共享变量的副本后，不会立即同步到主内存中，这就可能导致其他线程无法及时看到该变量的最新值，从而引发可见性问题。

可见性问题的产生

假设我们有两个线程，线程A和线程B，都访问共享变量count。线程A对count进行加1操作，线程B读取count的值。如果没有正确的同步机制，线程B读取到的count值可能不是线程A修改后的值，因为线程A修改count后，其修改结果可能还停留在自己的工作内存中，尚未同步到主内存，而线程B直接从主内存读取数据，此时就出现了可见性问题。以下是一个简单的代码示例：

public class VisibilityProblem {
    private static int count = 0;

    public static void main(String[] args) {
        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                count++;
            }
        });

        Thread threadB = new Thread(() -> {
            while (count < 1000) {
                // 这里线程B可能一直读取到count < 1000，因为count的修改可能未同步到主内存
            }
            System.out.println("Count value: " + count);
        });

        threadA.start();
        threadB.start();
    }
}

在上述代码中，threadB线程中的while循环可能会一直执行，因为count的修改在threadA线程的工作内存中，未及时同步到主内存，导致threadB线程无法看到count的最新值。

可见性与Java内存模型的关系

Java内存模型通过一些规则来保证共享变量的可见性，这些规则涉及到主内存与线程工作内存之间的数据交互。

主内存与工作内存的数据交互操作

read（读取）：将主内存中的变量值读取到线程的工作内存中。
load（载入）：将read操作读取到的值放入工作内存中的变量副本中。
use（使用）：将工作内存中变量副本的值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
assign（赋值）：将执行引擎返回的结果赋值给工作内存中的变量副本。
store（存储）：将工作内存中变量副本的值存储到主内存中。
write（写入）：将store操作存储的值放入主内存的变量中。

顺序一致性模型

顺序一致性模型是一个理论参考模型，它保证所有线程都只能看到一个一致的操作执行顺序。在顺序一致性模型中，所有操作（包括读和写）都是原子的，并且按照程序的顺序依次执行。然而，实际的Java内存模型并不完全遵循顺序一致性模型，因为在保证正确性的前提下，为了提高性能，JVM允许一定程度的指令重排序和缓存优化，这就导致了可见性问题的出现。

保证可见性的方式

在Java中，有多种方式可以保证共享变量的可见性。

volatile关键字

volatile的作用：volatile关键字可以保证变量的可见性。当一个变量被声明为volatile时，线程对该变量的写操作会立即同步到主内存中，而读操作会直接从主内存中读取，从而确保其他线程能够及时看到该变量的最新值。例如：

public class VolatileExample {
    private static volatile int volatileVariable = 0;

    public static void main(String[] args) {
        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                volatileVariable++;
            }
        });

        Thread threadB = new Thread(() -> {
            while (volatileVariable < 1000) {
                // 这里线程B会及时看到volatileVariable的变化
            }
            System.out.println("Volatile Variable value: " + volatileVariable);
        });

        threadA.start();
        threadB.start();
    }
}

在上述代码中，由于volatileVariable被声明为volatile，threadB线程能够及时看到threadA线程对volatileVariable的修改。 2. volatile禁止指令重排序：volatile不仅保证了可见性，还在一定程度上禁止了指令重排序。在生成字节码时，会在volatile变量的读操作和写操作前后加入内存屏障，以防止指令重排序。例如，以下代码中如果flag不是volatile的，JVM可能会对指令进行重排序：

public class VolatileReorder {
    private static int num;
    private static boolean flag;

    public static void writer() {
        num = 1; // 1
        flag = true; // 2
    }

    public static void reader() {
        if (flag) { // 3
            int result = num * 2; // 4
            System.out.println("Result: " + result);
        }
    }
}

如果flag是volatile的，那么在flag的写操作（2）和读操作（3）之间会插入内存屏障，保证在flag为true时，num一定已经被赋值为1，不会出现指令重排序导致num还未赋值就被读取的情况。

synchronized关键字

synchronized的可见性原理：synchronized关键字不仅可以保证线程安全，还可以保证可见性。当一个线程进入synchronized块时，它会先从主内存中读取共享变量的值，放入自己的工作内存中；当线程退出synchronized块时，会将工作内存中共享变量的最新值同步到主内存中。例如：

public class SynchronizedVisibility {
    private static int sharedValue = 0;

    public static void main(String[] args) {
        Thread threadA = new Thread(() -> {
            synchronized (SynchronizedVisibility.class) {
                for (int i = 0; i < 1000; i++) {
                    sharedValue++;
                }
            }
        });

        Thread threadB = new Thread(() -> {
            synchronized (SynchronizedVisibility.class) {
                while (sharedValue < 1000) {
                    // 这里线程B会及时看到sharedValue的变化
                }
                System.out.println("Shared Value: " + sharedValue);
            }
        });

        threadA.start();
        threadB.start();
    }
}

在上述代码中，由于synchronized块的存在，threadB线程在进入synchronized块时会从主内存读取sharedValue的最新值，从而能够及时看到threadA线程对sharedValue的修改。 2. synchronized与锁的释放和获取：从本质上讲，synchronized通过锁的释放和获取来保证可见性。当线程释放锁时，会将工作内存中的共享变量刷新到主内存；当线程获取锁时，会从主内存中重新读取共享变量的值到工作内存。这种机制确保了在同一把锁的保护下，线程对共享变量的操作具有可见性。

final关键字

final关键字对可见性的影响：final关键字修饰的变量一旦被初始化后，其值就不能再被修改。对于final修饰的字段，在对象构造完成后，只要对象的引用对其他线程可见，那么其他线程就能看到final字段的值。例如：

public class FinalVisibility {
    private final int finalValue;

    public FinalVisibility(int value) {
        finalValue = value;
    }

    public static void main(String[] args) {
        FinalVisibility instance = new FinalVisibility(10);
        Thread thread = new Thread(() -> {
            System.out.println("Final Value: " + instance.finalValue);
        });
        thread.start();
    }
}

在上述代码中，finalValue被final修饰，当FinalVisibility对象构造完成后，thread线程能够看到finalValue的值为10。 2. final关键字与对象构造过程中的可见性：在对象构造过程中，如果final字段没有正确初始化，可能会导致可见性问题。例如，如果在构造函数中通过一个静态方法来初始化final字段，而这个静态方法又可能被其他线程调用，就可能出现其他线程看到未完全初始化的final字段的情况。因此，在使用final关键字时，要确保final字段在对象构造完成前已经正确初始化。

深入理解可见性的底层原理

要深入理解Java内存模型中可见性的底层原理，我们需要了解一些硬件和操作系统层面的知识。

硬件层面的缓存一致性协议

现代计算机系统通常包含多级缓存，如L1、L2和L3缓存。每个CPU核心都有自己的L1和L2缓存，而L3缓存通常是多个CPU核心共享的。当CPU读取数据时，首先会从缓存中查找，如果缓存中没有，则从主内存中读取，并将数据加载到缓存中。同样，当CPU写入数据时，也会先写入缓存，然后再根据一定的策略将缓存中的数据同步到主内存中。

为了保证多个CPU核心缓存之间的数据一致性，现代硬件采用了缓存一致性协议，如MESI（Modified, Exclusive, Shared, Invalid）协议。MESI协议定义了缓存行（缓存中存储数据的最小单位）的四种状态：

Modified（修改）：缓存行中的数据被修改，与主内存中的数据不一致，并且该缓存行只被当前CPU核心缓存。
Exclusive（独占）：缓存行中的数据与主内存中的数据一致，并且该缓存行只被当前CPU核心缓存。
Shared（共享）：缓存行中的数据与主内存中的数据一致，并且该缓存行被多个CPU核心缓存。
Invalid（无效）：缓存行中的数据无效，需要从主内存中重新读取。

当一个CPU核心修改了处于Shared状态的缓存行中的数据时，会向其他CPU核心发送一个Invalidate消息，其他CPU核心收到该消息后，会将对应的缓存行状态设置为Invalid，从而保证了缓存一致性。Java内存模型中的可见性机制在一定程度上依赖于硬件层面的缓存一致性协议。

操作系统层面的内存管理

操作系统在管理内存时，会为每个进程分配独立的虚拟地址空间。虚拟地址空间通过页表映射到物理内存。当一个进程访问内存时，首先会通过虚拟地址查找页表，找到对应的物理地址，然后再访问物理内存。

在多线程环境下，操作系统需要保证线程之间共享内存的一致性。这通常通过一些同步机制来实现，如信号量、互斥锁等。Java中的synchronized关键字在底层实现上就与操作系统的同步机制相关。当一个线程获取到synchronized锁时，实际上是通过操作系统的同步原语来实现对共享资源的互斥访问，从而保证了可见性。

JVM层面的实现

字节码层面的指令：在字节码层面，JVM通过一些指令来实现可见性。例如，对于volatile变量的写操作，会生成putfield指令，并且在该指令前后插入内存屏障；对于volatile变量的读操作，会生成getfield指令，同样在该指令前后插入内存屏障。这些内存屏障指令会告诉CPU和编译器在指令执行时遵循一定的顺序，防止指令重排序，从而保证可见性。
运行时数据区与可见性：JVM的运行时数据区包括堆、栈、方法区等。共享变量存储在堆中，而线程的局部变量存储在栈中。线程对共享变量的访问通过栈帧中的操作数栈和局部变量表与堆中的共享变量进行交互。JVM通过控制这些数据区之间的数据传递和同步，来保证共享变量的可见性。例如，当一个线程对共享变量进行写操作时，JVM会将栈帧中的修改后的值同步到堆中，然后再根据内存模型的规则同步到主内存中。

可见性在实际应用中的场景

可见性在实际的Java多线程编程中有很多重要的应用场景。

单例模式中的可见性

在实现单例模式时，可见性是一个需要考虑的重要因素。例如，经典的双重检查锁（Double - Checked Locking）实现单例模式：

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

在上述代码中，instance被声明为volatile，这是为了防止指令重排序导致的可见性问题。在instance = new Singleton()这行代码中，实际上会进行三个步骤：分配内存空间、初始化对象、将instance指向分配的内存空间。如果没有volatile关键字，JVM可能会对这三个步骤进行重排序，先将instance指向分配的内存空间，然后再初始化对象。此时，如果另一个线程在对象还未初始化完成时访问instance，就会得到一个未完全初始化的对象。而volatile关键字可以禁止这种指令重排序，保证在instance被赋值后，对象已经完全初始化。

并发控制中的可见性

在并发控制中，保证共享变量的可见性对于正确实现同步机制至关重要。例如，在实现一个简单的计数器时，如果多个线程同时对计数器进行操作，并且需要保证每个线程都能看到最新的计数值，就需要使用volatile或synchronized来保证可见性。

public class Counter {
    private static volatile int count = 0;

    public static void increment() {
        synchronized (Counter.class) {
            count++;
        }
    }

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

在上述代码中，count被声明为volatile，并且在increment方法中使用synchronized来保证线程安全。这样，当一个线程调用increment方法增加count的值后，其他线程调用getCount方法能够获取到最新的计数值。

分布式系统中的可见性

在分布式系统中，不同节点之间的数据同步也涉及到可见性问题。虽然Java内存模型主要针对单机多线程环境，但其中的可见性概念在分布式系统中也有类似的应用。例如，在使用分布式缓存（如Redis）时，需要保证各个节点对缓存数据的可见性。当一个节点修改了缓存中的数据后，需要通过一定的机制（如发布 - 订阅模式、缓存一致性协议等）通知其他节点，使其他节点能够及时获取到最新的数据，这与Java内存模型中保证共享变量可见性的原理类似。

可见性相关的性能问题与优化

在保证可见性的同时，我们也需要关注性能问题，因为一些保证可见性的机制可能会带来一定的性能开销。

volatile关键字的性能影响

volatile关键字虽然保证了可见性和禁止指令重排序，但由于它会插入内存屏障，会对性能产生一定的影响。内存屏障会阻止CPU和编译器对指令进行重排序，这在一定程度上限制了优化的可能性。此外，每次对volatile变量的读写操作都需要与主内存进行同步，这也增加了内存访问的开销。因此，在使用volatile时，要权衡可见性需求和性能影响。如果变量的读写操作非常频繁，并且对性能要求较高，而可见性要求相对较低，可以考虑不使用volatile；如果变量的可见性至关重要，而读写操作不是特别频繁，可以使用volatile来保证可见性。

synchronized关键字的性能影响

synchronized关键字通过锁的机制来保证可见性和线程安全，但锁的获取和释放会带来较大的性能开销。在高并发环境下，大量线程竞争锁会导致线程上下文切换频繁，从而降低系统的性能。为了优化synchronized的性能，可以采用以下几种方法：

减小锁的粒度：将大的锁范围缩小，只对需要同步的关键代码块加锁。例如，在一个包含多个方法的类中，如果只有部分方法需要同步，可以为每个需要同步的方法分别加锁，而不是对整个类加锁。
使用读写锁：如果对共享资源的操作读多写少，可以使用读写锁（ReadWriteLock）。读写锁允许多个线程同时进行读操作，但只允许一个线程进行写操作，这样可以提高并发性能。
采用无锁数据结构：在一些场景下，可以采用无锁数据结构（如ConcurrentHashMap）来替代传统的加锁数据结构，从而避免锁的竞争，提高性能。

优化可见性性能的实践

合理使用缓存：在应用程序中，可以合理使用本地缓存来减少对共享变量的频繁读写。例如，对于一些不经常变化的数据，可以在本地缓存中保存一份副本，只有当数据发生变化时，再更新缓存并同步到共享变量。这样可以减少对共享变量的直接访问，提高性能。
减少不必要的同步：仔细分析代码逻辑，确定哪些操作真正需要同步，避免在不需要同步的地方加锁。例如，对于一些只读操作，可以不加锁，因为只读操作不会修改共享变量，不会引发线程安全和可见性问题。
使用线程本地变量：对于一些不需要在多个线程之间共享的数据，可以使用线程本地变量（ThreadLocal）。线程本地变量为每个线程提供独立的副本，避免了线程之间的竞争和同步开销，从而提高性能。

总结可见性相关的常见问题与解决方法

在实际编程中，与可见性相关的问题可能会比较隐蔽，以下是一些常见问题及解决方法。

可见性问题导致程序逻辑错误

问题描述：由于可见性问题，线程读取到的共享变量值不是最新的，从而导致程序逻辑错误。例如，在一个控制流程中，根据共享变量的值决定是否执行某个操作，但由于可见性问题，线程读取到的是旧值，导致操作执行错误。
解决方法：使用volatile关键字、synchronized关键字或其他同步机制来保证共享变量的可见性。例如，将控制流程中涉及的共享变量声明为volatile，或者在相关代码块上加synchronized锁。

性能问题与可见性需求的平衡

问题描述：为了保证可见性，使用了volatile或synchronized等机制，但这些机制带来了较大的性能开销，影响了系统的整体性能。
解决方法：仔细分析程序的性能瓶颈和可见性需求，采用合适的优化方法。如前文所述，可以通过减小锁的粒度、使用读写锁、采用无锁数据结构等方式来优化synchronized的性能；对于volatile，可以在保证可见性的前提下，尽量减少对volatile变量的读写操作，以降低性能开销。

指令重排序导致的可见性问题

问题描述：由于JVM的指令重排序，导致线程对共享变量的操作顺序与程序代码的顺序不一致，从而引发可见性问题。例如，在对象构造过程中，final字段的初始化顺序被重排序，导致其他线程看到未完全初始化的对象。
解决方法：使用volatile关键字禁止指令重排序，或者在关键代码段使用synchronized关键字，利用synchronized的内存屏障机制来防止指令重排序。对于final字段，要确保在对象构造完成前已经正确初始化，避免在构造函数中通过复杂的逻辑或可能被其他线程调用的方法来初始化final字段。

通过深入理解Java内存模型中的可见性概念、保证可见性的方式、底层原理、应用场景、性能问题及常见问题的解决方法，我们能够在多线程编程中更好地处理共享变量的可见性问题，编写高效、正确的多线程程序。在实际开发中，要根据具体的需求和场景，合理选择保证可见性的方法，在保证程序正确性的同时，尽可能提高性能。同时，不断关注硬件、操作系统和JVM的发展，了解新的技术和优化方法，以更好地应对多线程编程中的挑战。