5分钟搞懂JMM：10倍优化Java并发性能！

标签：10 Java 线程 内存 JMM 操作 搞懂 public

引言

在现代软件开发中，多线程并发编程已成为提高程序性能和资源利用率的关键技术。Java作为一种广泛使用的编程语言，提供了丰富的并发编程工具和框架。然而，要编写正确、高效且线程安全的并发程序，深入理解Java内存模型（JMM）是必不可少的。

Java内存模型(JMM) 是Java并发编程的核心概念之一，它定义了Java程序中变量的访问规则，以及这些变量如何与主内存（Java堆）进行交互。JMM不仅规定了线程之间共享变量的读写操作，还涵盖了这些操作的可见性、原子性和有序性。简而言之，JMM是一组规则，它确保了在多线程环境下，程序的行为是可预测和一致的。

JMM的重要性不仅体现在它对程序正确性的影响上，还体现在它对程序性能的潜在影响。正确理解和应用JMM可以帮助开发者避免常见的并发问题，如竞态条件和死锁，同时也能够优化程序性能，减少不必要的同步开销。

在本文中，我们将深入探讨JMM的工作原理，包括它的三大特性：原子性、可见性和有序性。我们将分析这些特性如何影响并发编程，并提供实际的代码示例来说明这些概念。此外，我们还将讨论JMM与指令重排序的关系，以及如何通过happens-before规则来保证程序的正确性。

通过本文的学习，读者将能够更好地理解JMM的复杂性，并掌握在实际编程中应用JMM的最佳实践。这不仅有助于提高代码质量，还能提升程序的性能和可靠性。

JMM的基本概念

Java内存模型（JMM）是一个抽象的概念，它描述了一组规则，这些规则定义了程序中变量的访问方式。在JMM的框架下，所有的变量都存储在主内存中，而每个线程拥有自己的工作内存，用于存储该线程使用的变量的拷贝。

定义JMM

JMM定义了线程和主内存之间的抽象关系，以及对共享变量的访问规则。它确保了在多线程访问共享变量时，即使在没有同步的情况下，也能保持一致的内存访问顺序。

主内存与工作内存

在JMM中，主内存（Main Memory）是所有线程共享的内存区域，用于存储所有线程共享的变量。而每个线程都有自己的工作内存（Working Memory），用于存储该线程私有的数据和对共享变量的拷贝。

• 主内存：主内存是Java堆中存储所有对象和变量的地方。它是所有线程默认的交互场所，任何线程对变量的修改都必须先在主内存中进行。

• 工作内存：工作内存是每个线程独有的数据区域，用于存储该线程中的变量。线程对变量的所有操作（读取、赋值）都必须在工作内存中进行，而不能直接读写主内存中的变量。

内存交互操作

JMM规定了主内存和工作内存之间变量的交互操作，包括：

• read：从主内存中读取一个变量值到工作内存。
• load：将read操作读取的值放入工作内存的变量副本中，以便之后使用。
• assign：将一个值赋给工作内存中的变量。
• use：将工作内存中的一个变量值传递给执行引擎。
• store：将一个变量值从工作内存传输到主内存。
• write：将store操作的值写入主内存的变量中。

这些操作确保了在多线程环境中，变量的修改能够被其他线程正确地观察到，从而维护了内存的一致性。

主内存与工作内存

在Java内存模型中，主内存和工作内存的概念是理解并发编程的关键。它们定义了线程如何与内存交互，以及如何保证在多线程环境下数据的一致性和可见性。

主内存的角色和功能

主内存是Java虚拟机（JVM）中所有线程共享的内存区域。它存储了所有的静态字段、数组和对象，以及这些对象的实例字段和类信息。主内存的主要功能包括：

• 数据共享：所有线程都可以通过主内存来共享数据。
• 变量存储：主内存中存储了所有线程共享的变量。
• 线程间通信：线程通过主内存来交换信息，例如，一个线程修改了主内存中的变量，其他线程可以通过读取主内存来获取这个变量的最新值。

工作内存的机制

每个线程都有自己的工作内存，它是该线程私有的数据区域。工作内存的主要功能包括：

• 数据缓存：线程可以将主内存中的数据复制到工作内存中，以便快速访问。
• 变量操作：线程对变量的所有操作（如读取、赋值）都必须在工作内存中进行。
• 减少竞争：通过在工作内存中进行操作，减少了对主内存的直接访问，从而降低了线程间的竞争。

线程的私有性

工作内存的私有性意味着每个线程只能访问自己的工作内存，而不能直接访问其他线程的工作内存。这种设计有助于：

• 隔离性：每个线程的操作不会直接影响到其他线程。
• 安全性：防止多个线程同时修改同一个变量，从而避免数据不一致的问题。
• 性能优化：通过减少对共享资源的访问，提高程序的执行效率。

示例：主内存与工作内存的交互

public class SharedVariable {
    public static int number = 0;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            number = 1; // 线程t1将number的值设置为1
        });

        Thread t2 = new Thread(() -> {
            if (number == 1) {
                System.out.println("Number is 1"); // 线程t2检查number的值
            }
        });

        t1.start();
        t2.start();
    }
}

在这个示例中，number变量存储在主内存中。线程t1修改了number的值，而线程t2读取了number的值。这个简单的示例展示了主内存和工作内存之间的交互。

内存交互操作

Java内存模型（JMM）定义了一组操作，这些操作规定了主内存和工作内存之间的交互方式。理解这些操作对于编写正确、高效的并发程序至关重要。

read和load操作

• read操作：这个操作允许线程从主内存中读取一个变量的值。read操作首先会检查该变量是否被锁定，如果没有被锁定，则将该变量的值从主内存传输到线程的工作内存中。
• load操作：load操作将read操作读取的值放入工作内存的变量副本中，以便线程之后使用。load操作是将数据从工作内存“移动”到线程的执行引擎中，以便执行引擎可以操作这些数据。

use操作

• use操作：use操作是指线程使用工作内存中的变量值。在JMM中，use操作必须在load操作之后进行，即线程不能使用尚未从主内存加载的变量值。

assign操作

• assign操作：assign操作是将一个值赋给工作内存中的变量。这个操作是线程对工作内存中的变量进行修改的第一步。

store和write操作

• store操作：store操作是将assign操作的值从工作内存传输到主内存。store操作是将数据从线程的工作内存“移动”到主内存中。
• write操作：write操作是将store操作的值写入主内存的变量中。write操作是将数据最终写入主内存，使得其他线程可以读取到这个更新后的值。

示例：内存交互操作

public class MemoryOperationsExample {
    public static int sharedVar = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            // 线程t1执行assign和store操作
            sharedVar = 10; // assign操作：将10赋值给工作内存中的sharedVar
            // 隐含了store操作：将10从工作内存传输到主内存中的sharedVar
        });

        Thread t2 = new Thread(() -> {
            // 线程t2执行read和load操作
            int value = sharedVar; // read操作：从主内存读取sharedVar的值
            // 隐含了load操作：将读取的值放入工作内存的sharedVar副本中
            System.out.println(value); // use操作：使用工作内存中的sharedVar值
        });

        t1.start();
        t1.join(); // 确保t1线程完成操作
        t2.start();
    }
}

在这个示例中，线程t1首先执行assign操作，将值10赋给工作内存中的sharedVar，然后隐含地执行store操作，将这个值传输到主内存。线程t2执行read操作从主内存读取sharedVar的值，然后隐含地执行load操作，将读取的值放入工作内存的sharedVar副本中，最后执行use操作，使用这个值。

JMM的三大特性

Java内存模型（JMM）通过三大特性来保证并发程序的正确性和性能：原子性（Atomicity）、可见性（Visibility）和有序性（Ordering）。这些特性是JMM的核心，它们定义了多线程环境下内存的访问规则。

原子性（Atomicity）

原子性是指一个操作或者一系列操作要么全部执行并且执行的过程不会被任何其他操作中断，要么就全部都不执行。在Java中，原子操作包括对基本数据类型的赋值和读取操作。

int i = 0; // 原子操作
i = 1;    // 原子操作

对于复合操作（如i++），它们在大多数情况下不是原子的，因为它们包含读取、增加和写入三个步骤。

可见性（Visibility）

可见性是指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。在Java中，volatile关键字可以保证变量的可见性。

public class VisibilityExample {
    private volatile boolean running = true;

    public void stop() {
        running = false;
    }

    public void test() {
        while (running) {
            // 循环体
        }
    }
}

在这个例子中，如果running变量没有被声明为volatile，那么在stop方法中对running的修改可能不会立即对test方法可见。

有序性（Ordering）

有序性是指在多线程环境中，操作的执行顺序需要遵守一定的规则。Java内存模型允许JVM和编译器对指令进行重排序以优化性能，但在某些情况下，我们需要禁止这种重排序以保证程序的正确性。

public class OrderExample {
    private int a = 0;
    private int b = 0;

    public void writer() {
        a = 1; // 步骤1
        b = 1; // 步骤2
    }

    public void reader() {
        if (a == 1) {
            System.out.println(b); // 步骤3
        }
    }
}

在这个例子中，如果编译器或JVM对writer方法中的步骤1和步骤2进行了重排序，那么reader方法中的步骤3可能会在a被设置为1之前打印出b的值。

JMM与指令重排序

在现代计算机系统中，为了提高执行效率，编译器和处理器常常会对指令进行重排序。这种重排序可能会干扰程序的并发执行，导致意想不到的结果，尤其是在多线程环境中。

什么是指令重排序

指令重排序是指编译器和处理器为了优化性能，可能会改变指令的执行顺序。这包括：

• 编译器重排序：编译器在代码生成时可能会重新排列代码的执行顺序。
• 处理器重排序：现代处理器使用流水线、超标量和乱序执行等技术，可能会在执行时改变指令的顺序。

指令重排序的影响

指令重排序可能会导致多线程程序中的数据竞争和内存可见性问题。例如，如果一个线程执行的操作被重排序，那么另一个线程可能看不到这些操作的预期效果。

JMM如何限制重排序

Java内存模型（JMM）通过happens-before规则来限制指令重排序，确保程序的正确性。这些规则定义了操作之间的内存可见性顺序，禁止某些可能会改变程序结果的重排序。

示例：指令重排序的影响

int a = 0, b = 0;
boolean flag = false;

public void writer() {
    a = 1; // 步骤1
    b = 1; // 步骤2
    flag = true; // 步骤3
}

public void reader() {
    if (flag) { // 步骤4
        System.out.println(a + " " + b);
    }
}

在这个例子中，如果编译器或处理器重排序了writer方法中的步骤1和步骤2，或者重排序了步骤2和步骤3，那么reader方法可能在flag被设置为true之前执行步骤4，导致输出不确定的结果。

防止指令重排序

为了防止这种重排序，我们可以使用volatile关键字来确保flag变量的写入对其他线程立即可见，并且不会被重排序。

volatile boolean flag = false;

public void writer() {
    a = 1; // 步骤1
    flag = true; // 步骤3，使用volatile保证可见性和防止重排序
    b = 1; // 步骤2
}

public void reader() {
    if (flag) { // 步骤4
        System.out.println(a + " " + b);
    }
}

通过将flag声明为volatile，我们确保了在writer方法中对flag的写入操作在步骤2和步骤3之后执行，这样reader方法就能看到正确的结果。

Happens-Before规则

在Java内存模型（JMM）中，happens-before原则是一组规则，用于确定一个操作何时对另一个操作可见。这些规则帮助我们理解和控制多线程环境中的内存可见性问题，确保程序的正确性。

什么是happens-before

如果一个操作A happens-before一个操作B，那么A的结果对B可见，且A的执行顺序在B之前。这意味着在A执行完毕后，B才能执行，A对共享变量所做的修改对B可见。

happens-before原则的规则

1. 程序顺序规则：在一个线程内，按照程序代码顺序，前面的操作happens-before后面的操作。
2. 监视器锁规则：对一个锁的解锁操作happens-before随后对这个锁的加锁操作。
3. volatile变量规则：对一个volatile变量的写操作happens-before后续对这个变量的读操作。
4. 传递性规则：如果操作A happens-before操作B，操作B happens-before操作C，那么操作A happens-before操作C。

示例：happens-before的应用

public class HappensBeforeExample {
    private static volatile boolean flag = false;
    private static int number = 0;

    public static void writer() {
        number = 42; // 步骤1：写入number
        flag = true; // 步骤2：写入flag
    }

    public static void reader() {
        if (flag) { // 步骤3：读取flag
            System.out.println(number); // 步骤4：读取number
        }
    }
}

在这个例子中，我们声明了flag为volatile变量。根据happens-before原则中的volatile变量规则，步骤2（写入flag）happens-before步骤3（读取flag）。由于传递性规则，步骤1（写入number）也happens-before步骤3（读取flag），因此步骤1同样happens-before步骤4（读取number）。这意味着当flag被设置为true时，number的值对reader方法可见。

通过理解和应用happens-before原则，我们可以在多线程环境中控制内存的可见性和操作的顺序，从而编写出正确且高效的并发程序。

JMM的实现与系统内核和CPU

Java内存模型（JMM）是一个抽象的概念，它需要在具体的系统内核和CPU层面上得到实现。这涉及到内存屏障和缓存一致性协议，它们确保了JMM规定的内存访问规则在硬件层面上得到遵守。

内存屏障

内存屏障（Memory Barrier），也称为内存栅栏，是一种CPU指令，用于控制特定类型的处理器重排序，确保CPU在执行后续指令前完成特定操作。内存屏障主要分为以下几类：

1. Load Barrier：确保所有在屏障之前的读操作完成后，才执行屏障之后的读操作。
2. Store Barrier：确保所有在屏障之前的写操作完成后，才执行屏障之后的写操作。
3. Full Barrier：同时具有读屏障和写屏障的功能，确保所有在屏障之前的读写操作完成后，才执行屏障之后的读写操作。

缓存一致性协议

缓存一致性协议（Cache Coherence Protocol）是一组规则，确保多个CPU核心或处理器的缓存中的数据保持一致。这些协议包括：

• MESI协议：修改（Modified）、独享（Exclusive）、共享（Shared）、无效（Invalid）是MESI协议的四种状态，用于跟踪缓存行的状态。
• MOESI协议：拥有（Owned）、独享（Exclusive）、共享（Shared）、无效（Invalid）和修改（Modified）是MOESI协议的五种状态，提供了比MESI协议更高效的缓存一致性维护。

JMM与缓存一致性协议

在Java中，volatile关键字和synchronized关键字在底层实现时，会利用缓存一致性协议来保证内存的可见性和原子性。例如，当一个线程写入一个volatile变量时，这个写入操作会通知其他CPU核心或处理器，使它们无效化对应的缓存行，从而确保所有线程看到的是最新的值。

示例：内存屏障的使用

public class MemoryBarrierExample {
    private static long x = 0L;
    private static long y = 0L;

    public static void writer() {
        x = 1L; // 步骤1：写入x
        // 内存屏障，确保x的写入完成
        // 此处在底层可能会插入Store Barrier
        y = 1L; // 步骤2：写入y
    }

    public static void reader() {
        long tempY = y; // 步骤3：读取y
        // 内存屏障，确保y的读取完成后再读取x
        // 此处在底层可能会插入Load Barrier
        long tempX = x; // 步骤4：读取x
        if (tempY == 1L && tempX == 1L) {
            System.out.println("X and Y are both set");
        }
    }
}

在这个例子中，我们通过内存屏障确保了在writer方法中对x和y的写入顺序，以及在reader方法中对y和x的读取顺序。这样可以避免因处理器重排序导致的潜在问题。

理解JMM在系统内核和CPU层面的实现，有助于我们更深入地理解并发编程中的内存可见性和原子性问题。通过内存屏障和缓存一致性协议，JMM确保了多线程程序的正确性和性能。

同步机制

在Java中，线程安全是并发编程的核心问题之一。为了确保多个线程在访问共享资源时不会引发数据不一致的问题，Java提供了多种同步机制，其中最常用的包括synchronized关键字和Lock接口。这些机制在Java内存模型（JMM）中扮演着重要角色，确保了原子性、可见性和有序性。

synchronized关键字

synchronized关键字是Java中最基本的同步机制。它可以用于方法或代码块，确保同一时间只有一个线程可以执行被synchronized修饰的代码。

使用方法

1. 同步实例方法：锁定当前对象的实例。

public synchronized void instanceMethod() {
    // 同步代码块
}

同步静态方法：锁定类的Class对象。

public static synchronized void staticMethod() {
    // 同步代码块
}

同步代码块：锁定指定对象。

public void method() {
    synchronized (this) {
        // 同步代码块
    }
}

Lock接口

Lock接口是Java 5引入的更灵活的同步机制。与synchronized相比，Lock提供了更高级的功能，如尝试锁定、定时锁定和可中断锁定。

使用方法

1. 创建Lock实例：

Lock lock = new ReentrantLock();

使用Lock进行同步：

lock.lock(); // 获取锁
try {
    // 保护的代码块
} finally {
    lock.unlock(); // 确保释放锁
}

synchronized与Lock的比较

• 灵活性：Lock提供了更灵活的锁定机制，可以尝试获取锁、定时锁定等，而synchronized是不可中断的。
• 性能：在高竞争的情况下，Lock可能比synchronized更高效，因为它可以减少上下文切换的开销。
• 可重入性：synchronized和Lock都支持可重入锁，但Lock提供了更细粒度的锁控制。

示例：使用synchronized和Lock

public class SynchronizedExample {
    private int count = 0;

    // 使用synchronized关键字
    public synchronized void increment() {
        count++;
    }
}

public class LockExample {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
        } finally {
            lock.unlock(); // 确保释放锁
        }
    }
}

在这两个示例中，SynchronizedExample类使用synchronized关键字来确保increment方法的线程安全，而LockExample类使用Lock接口来实现相同的功能。两者都能够确保在多线程环境中对count变量的安全访问。

理解Java中的同步机制是编写线程安全的并发程序的基础。通过合理使用synchronized和Lock，开发者可以确保在多线程环境中共享资源的安全访问，从而避免数据不一致和竞争条件的问题。

并发容器与JMM

Java提供了多种并发容器，它们在Java Collections Framework的基础上进行了扩展，以支持多线程环境。这些容器利用Java内存模型（JMM）的特性来保证线程安全，同时提供比传统同步容器更高的并发性能。

ConcurrentHashMap

ConcurrentHashMap是Java中的一个线程安全HashMap实现。它通过分段锁（Segmentation）和CAS操作来实现高并发访问。

工作原理

• 分段锁：ConcurrentHashMap将数据分成多个段，每个段有自己的锁。这样，当多个线程访问不同段的数据时，就不会产生锁竞争。
• CAS操作：ConcurrentHashMap在修改数据时，使用CAS（Compare-And-Swap）操作来保证原子性，这是一种无锁的非阻塞算法。

CopyOnWriteArrayList

CopyOnWriteArrayList是一个线程安全的变体ArrayList，适用于读多写少的场景。

工作原理

• 写时复制：当有写操作（如添加或删除元素）发生时，CopyOnWriteArrayList会创建当前数组的一个副本，在副本上进行修改，然后将原数组引用指向新数组。
• 读操作：读操作可以直接在原始数组上进行，因为它们不会改变数组的内容。

示例：使用ConcurrentHashMap

ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();

// 线程安全的put操作
map.put(1, "Item");

// 线程安全的get操作
String value = map.get(1);

在这个示例中，ConcurrentHashMap的put和get操作都是线程安全的，不需要额外的同步措施。

示例：使用CopyOnWriteArrayList

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

// 线程安全的add操作
list.add("Item");

// 线程安全的迭代操作
for (String item : list) {
    System.out.println(item);
}

在这个示例中，CopyOnWriteArrayList的add操作和迭代操作都是线程安全的，适合用于读多写少的场景。

并发容器在JMM框架下通过各种机制实现了线程安全，使得开发者可以更容易地编写高性能的并发程序。理解这些容器的工作原理和适用场景，可以帮助开发者在实际项目中做出正确的选择。

JMM对并发编程的影响

Java内存模型（JMM）对并发编程有着深远的影响。它不仅定义了线程如何正确地共享和修改数据，还对性能优化和程序的正确性有着重要的指导意义。

线程安全

JMM为线程安全提供了理论基础。通过定义主内存和工作内存之间的交互规则，JMM确保了在多线程环境中对共享变量的访问是安全的。开发者必须遵循这些规则来编写线程安全的代码。

性能优化

JMM允许JVM和编译器进行指令重排序以优化性能，但也引入了内存屏障等机制来控制重排序，以保证程序的正确性。理解这些机制可以帮助开发者在不牺牲程序正确性的前提下，优化程序性能。

编程实践

遵循JMM的最佳实践对于编写高质量的并发程序至关重要。以下是一些基于JMM的编程建议：

1. 慎用volatile：虽然volatile保证了变量的可见性，但它不保证复合操作的原子性。在使用volatile时，需要谨慎考虑是否满足需求。
2. 合理使用锁：通过synchronized或Lock接口，可以保证多个线程对共享资源的同步访问。合理使用锁可以避免死锁和活锁。
3. 减少锁的粒度：较大的锁粒度可能导致不必要的性能开销。通过细分锁的范围，可以提高程序的并发性能。
4. 利用并发容器：Java提供的并发容器，如ConcurrentHashMap和CopyOnWriteArrayList，是为高并发环境设计的。在适合的场景下使用它们，可以简化编程并提高性能。

示例：合理使用锁

import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

在这个示例中，我们使用ReentrantLock来保护对共享变量count的访问，确保了线程安全。

JMM是理解和编写Java并发程序的基石。通过深入理解JMM，开发者可以编写出既线程安全又高性能的并发程序。遵循JMM的最佳实践，合理使用同步机制和并发容器，可以帮助我们构建更健壮、更高效的并发应用。

结论

通过本文的深入探讨，我们了解了Java内存模型（JMM）的各个方面，从其定义、核心特性到在并发编程中的实践应用。JMM不仅规定了多线程程序中变量的访问规则，还对性能优化和程序的正确性有着重要的指导意义。

JMM的重要性

1. 保证线程安全：JMM通过定义原子性、可见性和有序性三大特性，帮助开发者编写出线程安全的代码。
2. 提高性能：JMM允许适当的指令重排序以提升性能，同时通过内存屏障等机制控制重排序，保证程序的正确执行。
3. 简化并发编程：JMM配合Java提供的并发容器和同步机制，简化了并发编程的复杂性，使得开发者可以更加专注于业务逻辑。

学习JMM的必要性

在现代多核处理器环境下，JMM的知识变得尤为重要。随着硬件的发展，多线程编程已成为提高程序性能的关键手段。深入理解JMM，可以帮助开发者：

• 避免常见的并发问题：如竞态条件、死锁等。
• 优化程序性能：合理利用JMM规则，减少不必要的同步开销。
• 编写高质量的并发代码：确保代码在多线程环境下的正确性和高效性。

最后的思考

JMM是一个复杂但极其重要的主题。对于任何希望在Java平台上进行高效并发编程的开发者来说，掌握JMM都是一项基本技能。我们鼓励读者继续深入学习JMM，不断实践，并关注Java并发领域的最新发展。

随着技术的不断进步，JMM和并发编程的实践也在不断演进。持续学习，不断适应新的编程模式和工具，将使您能够在构建高性能、高可靠性的Java应用时保持领先。

标签：10,Java,线程,内存,JMM,操作,搞懂,public
From： https://blog.csdn.net/mifffy_java/article/details/144224293