网站首页 > 文章精选正文

并发三大特性&Java内存模型JMM

balukai 2025-07-17 17:19:19 文章精选 5 ℃

并发和并行

其目标都是最大化CPU的使用率。

并行（parallel）

指同一时刻，有多条指令在多处理器上同时执行。所以无论从宏观还是微观上来看，二者都是一起执行的。

并发（concurrency）

基于CPU时间片，指在同一时刻只能有一条指令执行，但个进程指令被快速的轮换执行，使得在宏观上看具有多个进程同时执行的效果，但在微观上看并不是同时执行的，只是把时间分成若干段，使多个进程快速交替执行。

并行在多处理器系统中存在，而并发可以在单处理器或多处理器系统中都存在，并发能够在单处理器系统中存在是因为并发是并行的假象，并行要求程序能够同时执行多个操作，而并发只是要求程序假装同时执行多个操作（每个小时间片段执行一个操作，多个操作快速切换执行）。

并发三大特性

并发编程Bug的源头：可见性、原子性和有序性的问题。

可见性

当一个程序修改了共享变量的值，其他线程能够看到修改的值。Java内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值，这种依赖主内存作为传递媒介的方法来实现可见性。

保证可见性的方式

通过 volatile关键字保证可见性。
通过内存屏障保证可见性。
通过 synchronized关键字保证可见性。
通过Lock保证可见性。
通过final关键字保证可见性。

Java多线程对共享变量的可见性案例：

/**
 * 多线程变量可见性问题案例
 *
 * @Author warrior
 **/
public class VisibilityTest {

    //该方式定义多线程共享变量会存在可见性的问题
    private boolean flag = true;

    //采用volatile关键字保证共享变量的可见性
//    private volatile boolean flag = true;

    /**
     * 刷新变量flag的值
     */
    public void refresh() {
        this.flag = false;
        System.out.println(Thread.currentThread().getName() + ",修改了flag值为false");
    }

    /**
     * 执行操作
     */
    public void load() {
        System.out.println(Thread.currentThread().getName() + ",开始执行......");
        int i = 0;
        while (flag) {
            //TODO 其他业务处理
            i++;
            //volatile 修饰，共享变量可见性，跳出循环

            //采用内存屏障保证共享变量可见性,跳出循环
            //UnsafeFactory.getUnsafe().storeFence();

            //线程释放CPU时间片，再次执行，上下文切换，加载上下文信息值，跳出循环
            //Thread.yield();

            //短暂时间停止，让线程种的工作内存值失效，重新从主内存中加载
            //shortWait(1000000); //1ms

            //sleep，通过内存屏障,保证共享变量的可见性
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
        System.out.println(Thread.currentThread().getName() + ",跳出了循环:i=" + i);
    }

    /**
     * 短暂时间停止
     *
     * @param interval
     */
    private static void shortWait(long interval) {
        long start = System.nanoTime();
        long end;
        do {
            end = System.nanoTime();
        } while (start + interval >= end);
    }

    public static void main(String[] args) throws InterruptedException {
        VisibilityTest visibilityTest = new VisibilityTest();

        //开启一个线程threadA调用load方法
        Thread threadA = new Thread(() -> {
            visibilityTest.load();
        }, "threadA");
        threadA.start();

        //让threadA执行一会儿
        Thread.sleep(1000);

        //开启一个线程threadB控制threadA的执行时间
        Thread threadB = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + ",开始执行操作....");
            visibilityTest.refresh();
            System.out.println(Thread.currentThread().getName() + ",操作结束....");
        }, "threadB");
        threadB.start();
    }
}

有序性

即程序执行的顺序按照代码的先后顺序执行，JVM存在指令重排，所以存在有序性问题。

保证有序性的方式

通过volatile关键字保证有序性。
通过内存屏障保证有序性。
通过synchronized关键字保证有序性。
通过Lock保证有序性。

原子性

一个或多个操作，要么全部执行且在执行过程中不被任何因素打断，要么全部不执行。在Java中，对基本数据类型的变量的读取和赋值操作时原子性（64位处理器）。不采取任何的原子性保障措施的自增操作并不是原子性的。

保证原子性的方式

通过synchronized关键字保证原子性。
通过Lock保证原子性。
通过CAS保证原子性。

Java内存模型（JMM）

JMM定义

Java虚拟机规范中定义了Java内存模型（Java Memory Model），用于屏蔽掉各种硬件和操作系统的内存访问差异，实现让Java程序在各种平台下能够达到一致的并发效果，JMM规范了Java虚拟机与计算机内存是如何协同工作的，规定了一个线程如何和何时可以看到由其他线程修改过后的共享变量的值，以及在必须时如何同步访问的共享变量。JMM描述的时一种抽象的概念，一组规则，通过这组规则控制各个变量在共享数据区域和私有数据区域的访问方式，JMM是围绕原子性、有序性、可见性展开的。

JMM与硬件内存架构的关系

Java内存模型与硬件内存架构之间存在差异。硬件内存架构没有区分线程栈和堆，所有的线程栈和堆都分配在内存中。部分线程栈和堆可能有时候会出现在CPU缓存和CUP内部的寄存器中。Java内存模型和计算机硬件内存架构是一个交叉关系。

内存交互操作

主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存，如何从工作捏成同步到主内存之间的实现细节，Java内存模型定义了一下八种操作来完成：

lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。
unlock（解锁）:作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
read（读取）：作用域主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用。
load（载入）：作用于工作内存的变量，把read操作从主内存中得到的变量放入到工作内存的副本中。
use（使用）：作用于工作内存变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
assign（赋值）：作用域工作内存变量，把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个变量赋值的字节码指令时执行这个操作。
store（存储）：作用于工作内存的变量，把工作内存中的一个变量值传送到主内存中，以便随后的write的操作。
write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存中的变量中。

Java内存模型还规定了在执行上述八中基本操作时，必须满足一下规则：

如果要把一个变量从主内存中复制到工作内存，就需要按顺序的执行read和load操作，如果把变量从工作内存中同步回主内存，就要按顺序的执行store和write操作。Java内存模型只要求上述操作必须按顺序执行，而没有必要是连续执行。
不允许read和load、store和write操作之一单独出现。
不允许一个线程丢弃它最近assign的操作，及变量在工作内存中改变了之后必须同步到主内存中。
不允许一个线程无原因的（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
一个新的变量只能在主内存中诞生，不允许在工作内存中之间使用一个未被初始化（load或assign）的变量。即对一个变量实施use和store之前必须先执行assign和load操作。
如果一个变量执行了lock操作，将会清空工作内存中此变量的值

，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值。

如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作，也不允许去unlock一个被其他线程锁定的变量。
对一个变量unlock操作执行之前，必须先把变量值同步到主内存中（执行store和write操作）

JMM内存可见性保证

按程序类型，Java程序的内存可见性保证可以分为以下3类：

单线程程序：单线程不会出现内存可见性问题。编译器、runtime和处理器会共同确保单线程程序的执行结果与程序在顺序一致性模型中的执行结果相同。
正确同步的多线程程序：正确同步的多线程程序的执行具有顺序一致性。这是JMM关注的重点，JMM通过限制编译器和处理器的重排序来为程序员提供内存可见性的保证。
未同步/未正确同步的多线程程序：JMM为他们提供了最小的安全性保障。线程执行时读取到值，要么时之前某个线程写入的值，要么是默认值未同步在JMM中的执行值，整体上是无序的，其执行结果无法预知。JMM不保证未同步程序的执行结果与该线程在顺序一致性模型中的执行结果一致。

未同步程序在JMM中的执行时，整体上是无序的，其执行结果无法预知。未同步程序在两个模型中执行特性有如下几个差异：

顺序一致性模型保证单线程内的操作会按程序的顺序执行，而JMM不保证单线程内的操作会按程序的顺序执行，比如正确同步的多线程在临界区内的重排序。
顺序一致性模型保证所有线程只能看到一致性的操作执行顺序，而JMM不保证所有线程能看到一致性的操作执行顺序。
顺序一致性模型保证对多有的内存读/写操作都具有原子性，而JMM不保证对64位的long和double变量的写操作具有原子性（32位处理器）。

JVM在32位处理器上运行时，可能会把一个64位long/double型变量的写操作拆分为两个32位的写操作来执行。这两个32位的写操作可能会被分配到不同的总线事务中执行，此时对这个64位变量的写操作将不具有原子性。从JSR-133内存模型开始（即从JDK5开始），仅仅只允许把一个64位long/double型变量的写操作拆分为两个32位的写操作来执行，任意的读操作在JSR-133中都必须具有原子性

Volatile的内存语义

volatile的特性

可见性：对一个volatile变量的读，总是能看到任意线程对这个volatile变量最后的写入。
原子性：对任意单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不具有原子性（基于这一点，我们通常会认为volatile不具备原子性）。volatile仅仅保证对单个volatile变量的读/写具有原子性，而锁的互斥执行的特性可以确保对整个临界区代码的执行具有原子性。

64位的long型和double型变量，只要它是volatile变量，对该变量的读/写就具有原子性。

/**
 * 单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不具有原子性
 *
 * @Author warrior
 **/
public class AtomicityTest {

    private static volatile int sum = 0;

    public static void main(String[] args) {

        /**
         * 创建十个线程，每个线程sum自增1，操作一万次
         */
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    sum++;
                }
            }, "thread-" + i).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(sum);
    }
}

有序性：对volatile修饰的变量的读写操作前面加上各种特定的内存屏障来禁止指令重排序来保障有序性。

/**
 * 有序性案例demo
 *
 * @Author warrior
 **/
public class ReOrderTest {

    private static int x = 0, y = 0;
    private static volatile int a = 0, b = 0;

    private static void shortWait(long interval) {
        long start = System.nanoTime();
        long end;
        do {
            end = System.nanoTime();
        } while (start + interval >= end);
    }

    public static void main(String[] args) throws InterruptedException {

        int i = 0;

        while (true) {
            i++;
            x = 0;
            y = 0;
            a = 0;
            b = 0;

            Thread thread1 = new Thread(() -> {
                shortWait(2000);
                a = 1; //volatile 写
                //StoreLoad
                x = b;//volatile 读
            }, "thread1");

            Thread thread2 = new Thread(() -> {
                b = 1; //volatile写
                //storeLoad
                y = a; //volatile读
            }, "thread2");

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

            System.out.println("第" + i + "次（" + x + "," + y + ")");
            if (x == 0 && y == 0) {
                break;
            }
        }
    }
}

volatile写-读的内存语义

当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值刷新到主内存中。
当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效，线程接下来将从主内存中读取共享变量。

Volatile可见性实现原理

JMM内存交互层面实现

volatile修饰的变量的read、load、use和assign、store、write必须是连续的，即修改后必须立即同步回主内存，使用时必须从主内存刷新，由此保证volatile变量操作对多线程的可见性。

硬件层面实现

通过lock前缀指令，会锁定变量缓存行区域并写回主内存，这个操作称为”缓存锁定“，缓存一致性机会会阻止同时修改被两个以上的处理器缓存的内存区域数据。一个处理器的缓存回写到内存回导致其他处理器的缓存无效。

lock前缀指令的作用

确保后续指令执行的原子性。在Pentium及之前的处理器中，带有lock前缀的指令在执行期间会锁住总线，使得其它处理器暂时无法通过总线访问内存，很显然，这个开销很大。在新的处理器中，Intel使用缓存锁定来保证指令执行的原子性，缓存锁定将大大降低lock前缀指令的执行开销。
LOCK前缀指令具有类似于内存屏障的功能，禁止该指令与前面和后面的读写指令重排序。
LOCK前缀指令会等待它之前所有的指令完成、并且所有缓冲的写操作写回内存(也就是将store buffer中的内容写入内存)之后才开始执行，并且根据缓存一致性协议，刷新store buffer的操作会导致其他cache中的副本失效。

指令重排序

Java语言规范规定JVM线程内部维持顺序化语义。即只要程序的最终结果于它顺序化情况结果相等，那么指令的执行顺序可以与代码顺序不一致，此过程叫指令的重排序。

指令重排序的意义：JVM能根据处理器特性（CPU多级缓存系统、多核处理器等）适当的对机器指令进行重排序，使机器指令能更复合CPU的执行特性，最大限度的发挥机器的性能。

在编译器与CPU处理器中都能执行指令重排优化操作：

volatile重排序规则

volatile禁止重排序场景：

第二个操作是volatile写，不管第一个操作是什么都不会重排序
第一个操作是volatile读，不管第二个操作是什么都不会重排序
第一个操作是volatile写，第二个操作是volatile读，也不会发生重排序

上一篇：锂离子电池的不一致性影响因素及需要严控的电芯性能指标
下一篇： C++26中同步与原子操作新变化（c++ 同步）

网站首页 > 文章精选 正文

并发三大特性&amp;Java内存模型JMM