Java学习手册：Java内存模型-CSDN博客

本文链接：https://blog.csdn.net/weixin_44978801/article/details/147314421

Java内存模型

Java内存模型（Java Memory Model，简称JMM）是Java语言中用于定义线程之间如何共享和操作内存的规范。它描述了Java程序中变量的内存可见性行为，并定义了线程之间的通信规则。理解Java内存模型对于编写正确的并发程序至关重要。本文将深入探讨Java内存模型的基本概念、关键特性和优化策略。

Java内存模型的基本概念

Java内存模型定义了Java程序中变量的内存可见性和操作顺序。它主要包括以下几个核心概念：

内存结构

Java内存模型将内存分为两个主要部分：

主内存（Main Memory）：所有线程共享的内存区域，存储了对象实例和变量。
工作内存（Working Memory）：每个线程私有的内存区域，存储了该线程使用的变量副本。

线程之间的通信通过主内存进行。线程对变量的读写操作必须通过工作内存，不能直接操作主内存。

变量的内存可见性

Java内存模型确保线程对变量的修改对其他线程可见。这通过以下机制实现：

同步（Synchronization）：通过synchronized关键字确保线程之间的内存可见性。
volatile关键字：确保变量的修改对所有线程立即可见。
final关键字：确保对象的引用和初始化后的状态对所有线程可见。

Java内存模型的关键特性

Java内存模型定义了以下几个关键特性：

原子性

原子性确保操作在并发环境下是不可分割的，即操作要么完全执行，要么完全不执行。Java中的基本数据类型的赋值操作（如int、char等）是原子性的，但long和double类型的赋值操作可能不是原子性的。

示例代码：

public class AtomicityExample {
    private int count = 0;

    public void increment() {
        count++; // 不是原子操作
    }

    public int getCount() {
        return count;
    }
}

可见性

可见性确保一个线程对变量的修改对其他线程可见。Java通过synchronized、volatile和final关键字确保可见性。

示例代码：

public class VisibilityExample {
    private volatile boolean flag = false;

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public boolean getFlag() {
        return flag;
    }

    public static void main(String[] args) {
        VisibilityExample example = new VisibilityExample();
        new Thread(() -> {
            while (!example.getFlag()) {
                // 等待flag变为true
            }
            System.out.println("Flag已变为true");
        }).start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        example.setFlag(true);
    }
}

有序性

有序性确保程序的执行顺序与代码的书写顺序一致。Java内存模型允许编译器和处理器对指令进行重排序以优化性能，但通过happens-before规则确保程序的语义正确。

示例代码：

public class OrderingExample {
    private int a = 0;
    private boolean flag = false;

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

    public void reader() {
        if (flag) { // 3
            System.out.println(a); // 4
        }
    }
}

Java内存模型的优化策略

为了提高并发程序的性能，Java内存模型提供了以下优化策略：

减少锁的粒度

将大锁拆分为多个小锁，减少锁的争用。

示例代码：

import java.util.concurrent.locks.ReentrantLock;

public class FineGrainedLockExample {
    private final ReentrantLock lock1 = new ReentrantLock();
    private final ReentrantLock lock2 = new ReentrantLock();
    private int value1 = 0;
    private int value2 = 0;

    public void updateValue1(int value) {
        lock1.lock();
        try {
            value1 = value;
        } finally {
            lock1.unlock();
        }
    }

    public void updateValue2(int value) {
        lock2.lock();
        try {
            value2 = value;
        } finally {
            lock2.unlock();
        }
    }
}

使用无锁编程

通过原子变量和CAS操作实现无锁的并发控制。

示例代码：

import java.util.concurrent.atomic.AtomicInteger;

public class LockFreeExample {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

使用`final`修饰符

确保对象的引用和初始化后的状态对所有线程可见。

示例代码：

public class FinalExample {
    private final int value;

    public FinalExample(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}