我对Java内存模型的理解("深入解析Java内存模型：我的理解与实践")

原创

ithorizon 7个月前 (10-20) 阅读数 23 #后端开发

深入解析Java内存模型：我的明白与实践

一、Java内存模型的概述

Java内存模型（Java Memory Model，JMM）是Java虚拟机（JVM）的一部分，它定义了Java程序中各种变量（线程共享的变量）的访问规则，保证了不同线程之间的可见性和有序性。明白JMM对于编写高效且正确的并发程序至关重要。

二、Java内存模型的组成

Java内存模型关键由以下几个部分组成：

主内存（Main Memory）

工作内存（Working Memory）

内存屏障（Memory Barrier）

原子性（Atomicity）

可见性（Visibility）

有序性（Ordering）

三、主内存与工作内存

主内存是所有线程共享的内存区域，它存储了Java程序中的实例字段、静态字段和构成数组的元素。工作内存是每个线程私有的内存缓冲区，用于存储线程使用的变量的副本。

线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，之后的某个时间点再同步回主内存中。

四、内存屏障

内存屏障是一种同步机制，它保证了特定操作序列的执行顺序，防止编译器和处理器对操作序列进行重排序。JMM中关键有以下几种内存屏障：

Load Barrier：保证在屏障之前的读操作完成之后，才能执行屏障之后的读操作。

Use Barrier：保证在屏障之前的读操作完成之后，才能使用屏障之后的变量。

Store Barrier：保证在屏障之前的写操作完成之后，才能执行屏障之后的写操作。

Release Barrier：保证在屏障之前的操作全部完成之后，才能执行屏障之后的操作。

五、原子性

原子性指的是一个操作在其他线程看来是不可分割的，即线程在执行这些操作时不会被中断。JMM通过提供原子操作和锁来实现原子性。以下是一些常见的原子操作：


    boolean flag = true; // 赋值操作
    int i = a + b; // 算术运算
    i++; // 自增操作

六、可见性

可见性指的是当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。JMM通过volatile和synchronized两个关键字来保证可见性。

volatile变量的特性是保证任何一个线程读取变量时都会从主内存中重新读取数据，任何一个线程写入变量时都会立即同步回主内存中。

synchronized关键字通过加锁和解锁操作来保证可见性，当一个线程进入同步块时，它会清空工作内存中的共享变量值，当退出同步块时，它会将工作内存中的共享变量的最新值刷新回主内存中。

七、有序性

有序性指的是程序执行的顺序按照代码的先后顺序执行。JMM通过happens-before原则来保证有序性。以下是一些happens-before原则的例子：

单线程环境中的操作有序。

锁的释放操作happens-before于同一个锁的获取操作。

volatile变量的写操作happens-before于该变量的读操作。

线程的start()方法happens-before于线程的join()方法。

八、实践中的应用

明白JMM对于编写并发程序至关重要。以下是一些实践中的应用：

8.1 使用volatile关键字

使用volatile关键字可以保证变量的可见性，以下是一个示例：


    public class VolatileExample {
        private volatile boolean flag = false;
        public void setFlag() {
            flag = true;
        }
        public boolean getFlag() {
            return flag;
        }
    }

8.2 使用synchronized关键字

synchronized关键字可以保证原子性、可见性和有序性，以下是一个示例：


    public class SynchronizedExample {
        private int count = 0;
        public synchronized void increment() {
            count++;
        }
        public synchronized int getCount() {
            return count;
        }
    }

8.3 使用锁

使用锁可以保证多个操作的原子性，以下是一个示例：


    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    public class LockExample {
        private int count = 0;
        private final Lock lock = new ReentrantLock();
        public void increment() {
            lock.lock();
            try {
                count++;
            } finally {
                lock.unlock();
            }
        }
        public int getCount() {
            return count;
        }
    }