JMM（Java内存模型）

已于 2023-10-17 16:48:59 修改
阅读量836 收藏
点赞数
分类专栏： JMM Java内存模型 文章标签： java jvm
于 2021-04-06 09:00:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33507618/article/details/115428791
版权

JMM

一、CPU架构

在这里插入图片描述
现代计算机系统都加入了一层读写速度尽可能接近处理器运算速度的高速缓存（Cache）来作为内存与处理器之间的缓冲：将运算需要使用到的数据复制到缓存中，让运算能快速进行，当运算结束后再从缓存同步回内存之中，这样处理器就无须等待缓慢的内存读写了。

基于高速缓存的存储交互很好地解决了处理器与内存的速度矛盾，但是也为计算机系统带来更高的复杂度，因为它引入了一个新的问题：缓存一致性（Cache Coherence）。（当多个处理器的运算任务都涉及同一块主内存区域时，将可能导致各自的缓存数据不一致）

缓存一致性

缓存一致性协议给缓存行（通常为64字节）定义了个状态，用来描述该缓存行是否被多处理器共享、是否修改，缓存一致性协议最出名的是MESI协议。

MESI中每个缓存行都有四个状态，分别是独占E（exclusive）、修改M（modified）、共享S（shared）、失效I（invalid）。

  • 独占（exclusive）：仅当前处理器拥有该缓存行，并且没有修改过，是最新的值。
  • 共享（share）：有多个处理器拥有该缓存行，每个处理器都没有修改过缓存，是最新的值。
  • 修改（modified）：仅当前处理器拥有该缓存行，并且缓存行被修改过了，一定时间内会写回主存，写成功状态会变为S。
  • 失效（invalid）：缓存行被其他处理器修改过，该值不是最新的值，需要读取主存上最新的值。

协议协作如下（仅作了解）：

  • 一个处于M状态的缓存行，必须时刻监听所有试图读取该缓存行对应的主存地址的操作，如果监听到，则必须在此操作执行前把其缓存行中的数据写回CPU。
  • 一个处于S状态的缓存行，必须时刻监听使该缓存行无效或者独享该缓存行的请求，如果监听到，则必须把其缓存行状态设置为I。
  • 一个处于E状态的缓存行，必须时刻监听其他试图读取该缓存行对应的主存地址的操作，如果监听到，则必须把其缓存行状态设置为S。当CPU需要读取数据时，如果其缓存行的状态是I的，则需要从内存中读取，并把自己状态变成S，如果不是I，则可以直接读取缓存中的值，但在此之前，必须要等待其他CPU的监听结果，如其他CPU也有该数据的缓存且状态是M，则需要等待其把缓存更新到内存之后，再读取。
    - 当CPU需要写数据时，只有在其缓存行是M或者E的时候才能执行，否则需要发出特殊的RFO指令(Read Or Ownership，这是一种总线事务)，通知其他CPU置缓存无效(I)，这种情况下会性能开销是相对较大的。在写入完成后，修改其缓存状态为M。

二、基础概念

CPU相关术语

术语英文单词术语描述
内存屏障Memorybarriers 是一组处理器指令，用于实现对内存操作的顺序执行
缓存行Cache line缓存中可以分配的最小存储单位

原子性、可见性、有序性

  • 原子性： read、load、use、assign、store、write、lock、unlock 8个汇编指令；
  • 可见性：一个线程操作的变量要对其他线程可见；
  • 有序性：线程内都是有序，线程内观察别的线程都是无序的。（单线程有序，多线程可能指令重排序）

synchronized关键字是通过monitorenter和monitorexit两个字节码指令来实现的，所以它具有原子性。

三、JMM模型

线程的工作内存其实是cpu寄存器和高速缓存的抽象，并不真实存在。

线程之间的共享变量存储在主内存（Main Memory）中，每个线程都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的副本。

Java内存模型中规定了所有的变量都存储在主存中，每条线程还有自己的工作内存，线程对变量的所有操作（读取、赋值）都必须在工作内存中进行，而不能直接读写主内存中的变量，不同线程之间无法直接访问对方工作内存中的变量，线程间变量值的传递均需要在主内存来完成。
在这里插入图片描述

/**
 * 工作内存测试
 */
public class WorkCache {

    private static boolean initialization = false;

    /**
     * 主函数
     *
     * @param args 参数
     */
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            System.out.println("thread one start...");
            while (!initialization) {
            }
            System.out.println("thread one stop...");
        }).start();

        Thread.sleep(1000);

        new Thread(()->{
            System.out.println("thread two start...");
            init();
            System.out.println("thread two stop...");
        }).start();
    }

    public static void init() {
        initialization = true;
    }
}

结果：因为每个线程都有自己的工作内存，线程A对线程B的结果不可见，所以线程A一直没有结束。

thread one start...
thread two start...
thread two stop...

四、JMM内存分析

在这里插入图片描述

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

五、指令重排

Java虚拟机内存模型允许编译器和处理器对指令重排序以提高运行性能，并且不会对存在数据依赖关系的操作做重排序（这里所说的数据依赖性仅针对单个处理器中执行的指令序列和单个线程中执行的操作，多线程还是会指令重排序）。
在这里插入图片描述

  1. 编译器重排序：编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
  2. 指令级并行重排序：现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
  3. 内存系统重排序：由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。

as-if-serial语义

单线程语义as-if-serial的意思指：不管怎么重排序（编译器和处理器为了提高并行度），（单线程）程序的执行结果不能被改变。但在多线程程序中，对存在控制依赖的操作重排序，可能会改变程序的执行结果。编译器、runtime和处理器都必须遵守as-if-serial语义。

在这里插入图片描述

as-if-serial语义把单线程程序保护了起来，遵守as-if-serial语义的编译器、runtime和处理器共同为编写单线程程序的程序员创建了一个幻觉：单线程程序是按程序的顺序来执行的。as-if-serial语义使单线程程序员无需担心重排序会干扰他们，也无需担心内存可见性问题。

import java.util.HashSet;
import java.util.Set;

/**
 * 重排序
 */
public class Rerank {

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

    public static void main(String[] args) throws InterruptedException {
        Set<String> set = new HashSet<>();
        for (int i = 0; i < 10000000; i++) {
            x = 0;
            y = 0;
            a = 0;
            b = 0;
            Thread one = new Thread(() -> {
                a = 1;
                x = b;
            });
            Thread two = new Thread(() -> {
                b = 1;
                y = a;
            });
            one.start();
            two.start();
            one.join();
            two.join();
            String key = x + "-" + y;
            if (!set.contains(key)) {
                set.add(key);
                System.out.println("(" + x + "," + y + ")");
            }
        }
    }
}

结果：多线程之间，数据依赖也会发生重排序，所以出现了4种结果。

(0,1)
(1,0)
(0,0)
(1,1)

Happen-before语义

JVM对代码进行编译优化，会出现指令重排序情况，为了避免编译优化对并发编程安全性的影响，需要happens-before规则定义一些禁止编译优化的场景，保证并发编程的正确性。

在JMM中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须要存在happens-before关系，这里提到的两个操作既可以是在一个线程之内，也可以是在不同线程之间。

注意：两个操作之间具有happens-before关系，并不意味着前一个操作必须要在后一个操作之前执行！happens-before仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一个操作按顺序排在第二个操作之前。

JMM和happens-before的关系

与程序员密切相关的happens-before规则如下。

  1. 程序顺序规则：一个线程中的每个操作，happens-before于该线程中的任意后续操作。
  2. 监视器锁规则：对一个锁的解锁，happens-before于随后对这个锁的加锁。
  3. volatile变量规则：对一个volatile域的写，happens-before于任意后续对这个volatile域的读。
  4. 传递性：如果A happens-before B，且B happens-before C，那么A happens-before C。

重排序对多线程的影响

class ReorderExample {
	int a = 0;
	boolean flag = false;
	public void writer() {
		a = 1; // 1
		flag = true; // 2
	}
	Public void reader() {
		if (f?lag) { // 3
			int i = a * a; // 4
			……
		}
	}
}

flag变量是个标记，用来标识变量a是否已被写入。这里假设有两个线程A和B，A首先执行writer()方法，随后B线程接着执行reader()方法。线程B在执行操作4时，能否看到线程A在操作1对共享变量a的写入呢？不一定能看到。

由于操作1和操作2没有数据依赖关系，编译器和处理器可以对这两个操作重排序；同样，操作3和操作4没有数据依赖关系，编译器和处理器也可以对这两个操作重排序。

操作1和操作2做了重排序。程序执行时，线程A首先写标记变量flag，随后线程B读这个变量。由于条件判断为真，线程B将读取变量a。此时，变量a还没有被线程A写入，在这里多线程程序的语义被重排序破坏了！

操作3和操作4存在控制依赖关系。当代码中存在控制依赖性时，会影响指令序列执行的并行度。为此，编译器和处理器会采用猜测（Speculation）执行来克服控制相关性对并行度的影响。以处理器的猜测执行为例，执行线程B的处理器可以提前读取并计算a*a，然后把
计算结果临时保存到一个名为重排序缓冲（Reorder Buffer，ROB）的硬件缓存中。当操作3的条件判断为真时，就把该计算结果写入变量i中。

在单线程程序中，对存在控制依赖的操作重排序，不会改变执行结果（这也是as-if-serial语义允许对存在控制依赖的操作做重排序的原因）；但在多线程程序中，对存在控制依赖的操作重排序，可能会改变程序的执行结果。

六、内存屏障

为了保证内存可见性，Java编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序。

在多核CPU的情况下，因为多核CPU上的指令同时执行，如果涉及到共享变量的修改，这种优化会影响多线程运行的正确性，而内存屏障是硬件层面提供的一系列特殊指令，当CPU处理到这些指定时，会做一些特殊的处理，可以使处理器内的内存状态对其它处理器可见，在不同的平台上支持的内存屏障也会有差异。

  1. 阻止屏障两侧的指令重排序；
  2. 强制把写缓冲区/高速缓存中的脏数据等写回主内存，让缓存中相应的数据失效。

在JSR规范中定义了4种内存屏障：

屏障类型伪代码说明
LoadLoad屏障Load1; LoadLoad; Load2在Load2及后续读取操作要读取的数据被访问前，保证Load1要读取的数据被读取完毕
LoadStore屏障Load1; LoadStore; Store2在Store2及后续写入操作被刷出前，保证Load1要读取的数据被读取完毕
StoreStore屏障Store1; StoreStore; Store2在Store2及后续写入操作执行前，保证Store1的写入操作对其它处理器可见
StoreLoad屏障Store1; StoreLoad; Load2在Load2及后续所有读取操作执行前，保证Store1的写入对所有处理器可见

为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。代码如下：

/**
 * volatile保证可见性
 */
public class Visible {
    private static volatile boolean initialization = false;
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            System.out.println("thread one start...");
            while (!initialization) {
            }
            System.out.println("thread one stop...");
        }).start();

        Thread.sleep(1000);

        new Thread(()->{
            System.out.println("thread two start...");
            init();
            System.out.println("thread two stop...");
        }).start();
    }

    public static void init() {
        initialization = true;
    }
}

结果：

thread one start...
thread two start...
thread two stop...
thread one stop...

内存屏障的实现

源代码：

inline void OrderAccess::loadload() { compiler_barrier(); }
inline void OrderAccess::storestore() { compiler_barrier(); }
inline void OrderAccess::loadstore() { compiler_barrier(); }
inline void OrderAccess::storeload() { fence(); }
inline void OrderAccess::acquire() { compiler_barrier(); }
inline void OrderAccess::release() { compiler_barrier(); }
inline void OrderAccess::fence() {
// always use locked addl since mfence is sometimes 
expensive
#ifdef AMD64
__asm__ volatile ("lock; addl $0,0(%%rsp)" : : : "cc", 
"memory");
#else
__asm__ volatile ("lock; addl $0,0(%%esp)" : : : "cc", 
"memory");
#endif
compiler_barrier();
}

volatile可见性的实现

有volatile变量修饰的共享变量进行写操作的时候会使用CPU提供的Lock前缀指令：

  • 将当前处理器缓存行的数据写回到系统内存；
  • 这个写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效。
if (cache->is_volatile()) {
	switch (tos_type) {
		case ztos:
			obj->release_byte_field_put(field_offset, (STACK_INT(-1) & 1)); // only store LSB
			break;
		………….. 
}
		default:
		ShouldNotReachHere();
	}
	OrderAccess::storeload();
}

七、可见性内存分析

在这里插入图片描述
如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是，就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题。所以，在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。

八、重识双检锁

/**
 * 双重检查单例
 */
public class DclSingleton {
    private static DclSingleton instance; // 这里没有volatile，instance = new DclSingleton();可能发生重排序而产生多个对象
    public static DclSingleton getInstance() {
        if (null == instance) {
            synchronized (DclSingleton.class) {
                if (null == instance) {
                    instance = new DclSingleton();
                }	
            }
        }
        return instance;
    }
    public static void main(String[] args) {
        DclSingleton.getInstance();
    }
}

memory = allocate(); // 1：分配对象的内存空间
ctorInstance(memory); // 2：初始化对象
instance = memory; // 3：设置instance指向刚分配的内存地址

重排序后：

memory = allocate(); // 1：分配对象的内存空间
instance = memory; // 3：设置instance指向刚分配的内存地址， 注意，此时对象还没有被初始化！
ctorInstance(memory); // 2：初始化对象

九、CAS

独占锁是一种悲观锁，synchronized就是一种独占锁，会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。

而另一个更加有效的锁就是乐观锁，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。


import java.util.ArrayList;
import java.util.List;

/**
 * 计数器
 */
public class Counter {

    private static volatile int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        List<Thread> threadList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            threadList.add(new Thread(() -> {
                for (int k = 0; k < 10000; k++) {
                    counter++;
                }
            }));
        }
        for (Thread thread : threadList) {
            thread.start();
        }
        for (Thread thread : threadList) {
            thread.join();
        }
        System.out.println(counter);
    }
}

结果可能有很多种：

173576

atomic包

使用循环CAS实现原子操作

JVM中的CAS操作正是利用了处理器提供的CMPXCHG指令实现的。自旋CAS实现的基本思路就是循环进行CAS操作直到成功为止，以下代码实现了一个基于CAS线程安全的计数器。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 计数器
 */
public class SafeCounter {

    private static AtomicInteger counter = new AtomicInteger();

    public static void main(String[] args) throws InterruptedException {
        List<Thread> threadList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            threadList.add(new Thread(() -> {
                for (int k = 0; k < 10000; k++) {
                	// 手动实现自旋锁
                    while(true) {
                        int count = counter.get();
                        boolean success = counter.compareAndSet(count, count + 1);
                        if (success) {
                            break;
                        }
                    }
                }
            }));
        }
        for (Thread thread : threadList) {
            thread.start();
        }
        for (Thread thread : threadList) {
            thread.join();
        }
        System.out.println(counter.get());
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 计数器
 */
public class SafeCounter1 {

    private static AtomicInteger counter = new AtomicInteger();

    public static void main(String[] args) throws InterruptedException {
        List<Thread> threadList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            threadList.add(new Thread(() -> {
                for (int k = 0; k < 10000; k++) {
                	// 源码实现自旋锁
                    counter.getAndIncrement();
                }
            }));
        }
        for (Thread thread : threadList) {
            thread.start();
        }
        for (Thread thread : threadList) {
            thread.join();
        }
        System.out.println(counter.get());
    }
}


// 源码
public final int getAndAddInt(Object var1, long var2, int var4) {
   int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}
抽抽了
关注
专栏目录
面试官问我什么是JMM
yehongzhi1994的博客
09-20 2389
什么是JMM，什么是内存屏障，看这篇就够了
jvm八种原子性操作及synchronized锁机制
JavaBlackHole的博客
11-28 1743
Java内存模型--同步协议 关于主内存与工作内存之间的交互协议，即一个变量如何从主内存拷贝到工作内存。如何从工作内存同步到主内存中的实现细节。java内存模型定义了8种操作来完成,每一种都是原子操作: lock(锁定)：作用于主内存，它把一个变量标记为一条线程独占状态； read(读取)：作用于主内存，它把变量值从主内存传送到线程的工作内存中，以便随后的load动作使用； ...
Java 内存模型（JMM）
最新发布
qq_63688997的博客
09-19 1478
JMM，全称 Java Memory Model ，中⽂释义Java内存模型。
深入理解Java内存模型
zgmzyr的专栏
04-13 6501
转载于：http://www.infoq.com/cn/articles/java-memory-model-1?utm_source=infoq&utm_medium=related_content_link&utm_campaign=relatedContent_articles_clk 深入理解Java内存模型（一）——基础 并发编程模型的分类 在并
JMM模型
星星的技术专栏
11-06 1994
一、指令重排序 1.javac生成字节码时，及字节码被JIT编译器编译成本地代码时，会进行指令的重排序 2.处理器可以乱序和并发执行指令 3.如果没有充分同步，在另一个线程中完全可以看到一个线程代码执行顺序和“理所当然”的顺序不一致以上的程序，可能会打印出x=0,y=0;x=1,y=0;x=0,y=1;x=1,y=1 4.要使程序的执行可以预测，JMM必然会做一些规定限制，那就是happens-before规则，final初始化规则二、happens-before 1.是一种偏序关系2.规则：（1
【Java内存模型】Java内存模型（JMM）详解以及并发编程的三个重要特性（原子性，可见性，有序性）
小七的博客
02-14 3855
目录 1 Java内存模型（Java memory model JMM） 1.1 什么是JMM（JMM的作用） 1.2 JMM的组成 2 硬件内存架构与java内存模型 2.1 硬件架构 2.2 Java线程与硬件处理器 2.3 Java内存模型与硬件内存架构的关系 2.4 Java内存模型的必要性 3.并发编程的三个重要特性 3.1 原子性 3.2 可见性 3.3...
Java内存模型详解JMM.docx
05-03
Java内存模型详解JMM Java内存模型（Java Memory Model，JMM）是Java虚拟机（JVM）中的一种内存模型，它描述了程序中各个变量之间的关系，以及在实际计算机系统中将变量存储到内存和从内存中取出变量这样的底层细节...
JMM Java内存模型
u014474768的博客
03-29 380
多线程之间要配合，谁先谁后要互相让其他线程感知，要遵守Happens-Before，才能满足多线程之间的可见性。否则就不能对另一个操作可见或者禁止代码重排序。
Java内存模型(Java Memory Model，JMM)
2401_83817171的博客
04-17 627
关于面试刷题也是有方法可言的，建议最好是按照专题来进行，然后由基础到高级，由浅入深来，效果会更好。Java基础部分算法与编程数据库部分流行的框架与新技术（Spring+SpringCloud+SpringCloudAlibaba）这份面试文档当然不止这些内容，实际上像JVM、设计模式、ZK、MQ、数据结构等其他部分的面试内容均有涉及，因为文章篇幅，就不全部在这里阐述了。
浅析java内存模型--JMM(JavaMemoryModel)
02-24
在说Java内存模型之前，我们先说一下Java的内存结构，也就是运行时的数据区域：Java虚拟机在执行Java程序的过程中，会把它管理的内存划分为几个不同的数据区域，这些区域都有各自的用途、创建时间、销毁时间
Java内存模型JMM浅析
12-22
　并发编程有多种风格，除了CSP(通信顺序进程)、Actor等模型外，大家熟悉的应该是基于线程和锁的共享内存模型了。在多线程编程中，需要注意三类并发问题: 　1、原子性 　2、可见性 　3、重排序 　原子性涉及到...
JMM内存模型
纯洁的小魔鬼
07-08 530
一.硬件的效率与一致性 在现代计算机系统中，CUP，内存和IO的处理速度是 CUP > 内存 > IO，由于计算机的存储设备与CPU的运算速度有几个数量级的差距，所以现代计算机系统都会引入一层读写速度尽可能接近处理器运算速度的高速缓存来作为内存与处理器之间的缓冲：将运算需要使用到的数据复制到缓存中，让运算能快速进行，当运算结束后再从缓存同步回内存之中，这样处理器就无需等待缓慢的内存读写了。 基于高速缓存的存储交互很好地解决了处理器与内存的速度矛盾，但是它引入...
全面理解Java内存模型
路漫漫其修远兮
02-20 924
Java内存模型即Java Memory Model，简称JMM。JMM定义了Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式。JVM是整个计算机虚拟模型，所以JMM是隶属于JVM的。如果我们要想深入了解Java并发编程，就要先理解好Java内存模型。Java内存模型定义了多线程之间共享变量的可见性以及如何在需要的时候对共享变量进行同步。原始的Java内存模型效率并不是很理想，因此Jav
Java 内存模型(JMM)
半夏_2021的博客
08-11 3522
文章目录什么是JMM模型JMM和JVM的区别主内存和工作内存Java内存模型与硬件内存架构的关系JMM存在的必要性 什么是JMM模型 Java内存模型(Java Memory Model简称JMM)是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。 JVM运行程序的实体是线程，而每个线程创建时,JVM都会为其创建一个工作内存(有些地方称为栈空间)，用于存储线程私有的数据。 Java内存模型中规定所有变量都存储在
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

抽抽了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值