AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

《Java 并发编程》共享模型之内存

2023-02-21 162
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 《Java 并发编程》共享模型之内存

Java 内存模型（Java Memory Model，JMM），定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存和 CPU 指令优化等。2e718f6de6d94987ae2f2182c528d9c8.png

JMM 体现在以下几个方面：

  • 原子性：保证指令不受到线程上下文的影响。
  • 可见性：保证指令不会受 CPU 缓存的影响。
  • 有序性：保证指令不会受 CPU 指令并行优化的影响。

🚀1. 原子性

原子性（Atomicity）：由 Java 内存模型来直接保证的原子性变量操作包括 read、load、assign、use、store 和 write，基本数据类型的访问读写是具备原子性的（除了 long 和 double 的非原子性协定）。


问题：

两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果是 0 吗？


问题分析：

以上的结果可能是正数、负数、零，因为 Java 中对静态变量的自增，自减并不是原子操作。


例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：

getstatic i // 获取静态变量i的值 
iconst_1 // 准备常量1 
iadd // 加法 
putstatic i // 将修改后的值存入静态变量i

而对应 i-- 也是类似：

getstatic i // 获取静态变量i的值 
iconst_1 // 准备常量1 
isub // 减法 
putstatic i // 将修改后的值存入静态变量i

而 Java 的内存模型如下，完成静态变量的自增、自减需要在主存和线程内存中进行数据交换：2e718f6de6d94987ae2f2182c528d9c8.png

如果是单线程以下 8 行代码是顺序执行（不会交错）没有问题：

// 假设i的初始值为0 
getstatic i // 线程1-获取静态变量i的值 线程内i=0 
iconst_1 // 线程1-准备常量1 
iadd // 线程1-自增 线程内i=1 
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1 
getstatic i // 线程1-获取静态变量i的值 线程内i=1 
iconst_1 // 线程1-准备常量1 
isub // 线程1-自减 线程内i=0 
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=0

但多线程下这 8 行代码可能交错运行，出现负数的情况：

// 假设i的初始值为0 
getstatic i // 线程1-获取静态变量i的值 线程内i=0 
getstatic i // 线程2-获取静态变量i的值 线程内i=0 
iconst_1 // 线程1-准备常量1 
iadd // 线程1-自增 线程内i=1 
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1 
iconst_1 // 线程2-准备常量1 
isub // 线程2-自减 线程内i=-1 
putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1

出现正数的情况：

// 假设i的初始值为0 
getstatic i // 线程1-获取静态变量i的值 线程内i=0 
getstatic i // 线程2-获取静态变量i的值 线程内i=0 
iconst_1 // 线程1-准备常量1 
iadd // 线程1-自增 线程内i=1 
iconst_1 // 线程2-准备常量1 
isub // 线程2-自减 线程内i=-1 
putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1 
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1

解决方法：

使用 synchronized （关键字）

语法：

synchronized(对象) {
  要作为原子操作的代码
}

加上 synchronized 关键字后的案例代码：

public class Demo4_1 {
    static int i = 0;
    static Object obj = new Object();
    public static void main(String[] args) throws InterruptedException{
        Thread t1 = new Thread(() -> {
            for (int j = 0; j < 5000; j++) {
                synchronized (obj) {
                    i++;
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int j = 0; j < 5000; j++) {
                synchronized (obj) {
                    i--;
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

🚀2. 可见性

案例：main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止：

public class Demo4_2 {
    static boolean run = true;
    public static void main(String[] args) throws InterruptedException{
        Thread t = new Thread(() -> {
            while (run) {
            }
        });
        t.start();
        Thread.sleep(1000);
        run = false;  // 线程t不会如预想的停下来
    }
}

原因分析：

  1. 初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存。

2e718f6de6d94987ae2f2182c528d9c8.png

.因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，减少对主存中 run 的访问，提高效率。2e718f6de6d94987ae2f2182c528d9c8.png

1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读取这个变量的值，结果永远是旧值。

2e718f6de6d94987ae2f2182c528d9c8.png

解决方法：


使用 volatile 关键字。volatile 用来修饰成员变量和静态成员变量，它可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存。


退不出循环的例子体现的实际就是可见性，它保证的是在多个线程之间，一个线程对 volatile 变量的修改对另一个线程可见， 不能保证原子性，仅用在一个写线程，多个读线程的情况：上例从字节码理解是这样的：2e718f6de6d94987ae2f2182c528d9c8.png

解决方法：


使用 volatile 关键字。volatile 用来修饰成员变量和静态成员变量，它可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存。


退不出循环的例子体现的实际就是可见性，它保证的是在多个线程之间，一个线程对 volatile 变量的修改对另一个线程可见， 不能保证原子性，仅用在一个写线程，多个读线程的情况：上例从字节码理解是这样的：

getstatic run // 线程 t 获取 run true 
getstatic run // 线程 t 获取 run true 
getstatic run // 线程 t 获取 run true 
getstatic run // 线程 t 获取 run true 
putstatic run // 线程 main 修改 run 为 false， 仅此一次 
getstatic run // 线程 t 获取 run false

与 synchronized 不同的是，例如当使用 volatile 作用之前的线程安全案例时，两个线程一个 i++ 和一个 i-- ，只能保证看到最新值，不能解决指令交错。

// 假设i的初始值为0 
getstatic   // 线程2-获取静态变量i的值 线程内i=0
getstatic i // 线程1-获取静态变量i的值 线程内i=0 
iconst_1 // 线程1-准备常量1 
iadd // 线程1-自增 线程内i=1 
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1 
iconst_1 // 线程2-准备常量1 
isub // 线程2-自减 线程内i=-1 
putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1

需要注意的是，synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是 synchronized 是属于重量级操作，性能相对更低，如果在前面示例的死循环中加入 System.out.println() 会发现即使不加 volatile 修饰符，线程 t 也能正确看到对 run 变量的修改了。

public class Demo4_2 {
    volatile static boolean run = true;
    public static void main(String[] args) throws InterruptedException{
        Thread t = new Thread(() -> {
            while (run) {
                System.out.println();
            }
        });
        t.start();
        Thread.sleep(1000);
        run = false;  // 线程t不会如预想的停下来
    }
}

需要注意的是，synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是 synchronized 是属于重量级操作，性能相对更低，如果在前面示例的死循环中加入 System.out.println() 会发现即使不加 volatile 修饰符，线程 t 也能正确看到对 run 变量的修改了。

public class Demo4_2 {
    volatile static boolean run = true;
    public static void main(String[] args) throws InterruptedException{
        Thread t = new Thread(() -> {
            while (run) {
                System.out.println();
            }
        });
        t.start();
        Thread.sleep(1000);
        run = false;  // 线程t不会如预想的停下来
    }
}

这是因为，println 方法底层加了 synchronized 关键字，保证了可见性。

/**
 * Prints an integer and then terminate the line.  This method behaves as
 * though it invokes <code>{@link #print(int)}</code> and then
 * <code>{@link #println()}</code>.
 *
 * @param x  The <code>int</code> to be printed.
 */
public void println(int x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

🚁2.1 模式之两阶段终止

两阶段终止（Two Phase Termination），在一个线程 t1 如何 “优雅” 终止线程 t2？这里的 “优雅” 是指给 t2 一个 “结束前处理的机会”。


❌错误思路


使用线程对象的 stop() 方法停止线程：stop 会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其他线程将永远无法获取锁。

使用 System.exit() 方法停止线程：目的仅是停止一个线程，但这种做法会让整个程序都停止。

✅两阶段终止


利用 isInterrupted

interrupt 可以打断正在执行的线程，无论这个线程是在 sleep，wait 还是正常运行

public class TPTInterrupt {
    private Thread thread;
    public void start() {
        thread = new Thread(()->{
            while (true) {
                Thread current = Thread.currentThread();
                if (current.isInterrupted()) {
                    System.out.println("结束前处理");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    System.out.println("将结果保存");
                } catch (InterruptedException e) {
                    current.interrupt();
                }
                //执行监控
            }
        }, "监控线程");
        thread.start();
    }
    public void stop() {
        thread.interrupt();
    }
    public static void main(String[] args) throws InterruptedException {
        TPTInterrupt t = new TPTInterrupt();
        t.start();
        Thread.sleep(4000);
        System.out.println("stop");
        t.stop();
    }
}

运行结果

将结果保存
将结果保存
将结果保存
stop
结束前处理
  1. 利用停止标记
public class TPTVolatile {
    private Thread thread;
    private volatile boolean stop = false;
    public void start() {
        thread = new Thread(()->{
            while (true) {
                Thread current = Thread.currentThread();
                if (stop) {
                    System.out.println("结束前处理");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    System.out.println("将结果保存");
                } catch (InterruptedException e) {
                }
                //执行监控
            }
        }, "监控线程");
        thread.start();
    }
    public void stop() {
        stop = true;
        thread.interrupt();
    }
    public static void main(String[] args) throws InterruptedException {
       TPTVolatile t = new TPTVolatile();
       t.start();
       Thread.sleep(4000);
       System.out.println("stop");
       t.stop();
    }
}

运行结果

将结果保存
将结果保存
将结果保存
stop
结束前处理

🚁2.2 同步模式之犹豫模式

定义：：犹豫（Balking）模式用在一个线程发现另外一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做，直接结束返回。

  • 用一个标记来判断该任务是否已经被执行过了
  • 需要避免线程安全问题。加锁的代码块要尽量的小，以保证性能

实现

public class MonitorService {
    public static void main(String[] args) throws InterruptedException {
        Monitor monitor = new Monitor();
        monitor.start();
        monitor.start();
        monitor.start();
        monitor.start();
        Thread.sleep(3500);
        monitor.stop();
    }
}
class Monitor {
    Thread monitor;
    //设置标记，用于判断是否被终止了
    private volatile boolean stop = false;
    //设置标记，用于判断是否已经启动过了
    private boolean starting = false;
    /**
     * 启动监控器线程
     */
    public void start() {
        //上锁，避免多线程运行时出现线程安全问题
        synchronized (this) {
            if (starting) {
                //已被启动，直接返回
                System.out.println("监控线程已启动?"+starting);
                return;
            }
            //启动监视器，改变标记
            System.out.println("监控器已启动？"+starting);
            starting = true;
        }
        //设置监控器线程，用于监控线程状态
        monitor = new Thread(() -> {
            //开始不停的监控
            while (true) {
                if(stop) {
                    System.out.println("处理后续任务");
                    break;
                }
                System.out.println("监控器运行中...");
                try {
                    //线程休眠
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("被打断了");
                }
            }
        });
        monitor.start();
    }
    /**
     *  用于停止监控器线程
     */
    public void stop() {
        //打断线程
        monitor.interrupt();
        stop = true;
    }
}

运行结果

监控器已启动？false
监控线程已启动?true
监控线程已启动?true
监控线程已启动?true
监控器运行中...
监控器运行中...
监控器运行中...
监控器运行中...
被打断了
处理后续任务

还可以用来实现线程安全的单例

public final class Singleton {
    private Singleton() {}
    private static Singleton INSTANCE = null;
    public static synchronized Singleton getInstance() {
        // 实例没创建，才会进入内部的 synchronized代码块
        if (INSTANCE == null) {
            return INSTANCE;
            }
        }
        INSTANCE = new INSTANCE();
        return INSTANCE;
    }
}

🚀3. 有序性

🚁3.1 指令重排

JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，例如下面的代码：

static int i;
static int j;
//在某个线程内执行如下赋值操作
i = ...;
j = ...;

可以看到，至于先执行 i 还是先执行 j，对最终的结果不会产生影响，因此，上面代码真正执行时，既可以是

i = ...;
j = ...;

也可以是

j = ...;
i = ...;

这种特性称之为【指令重排】，多线程下【指令重排】会影响正确性。 例如著名的 double-checkedlocking 模式实现单例：

public final class Singleton {
    private Singleton() {}
    private static Singleton INSTANCE = null;
    public static Singleton getInstance() {
        // 实例没创建，才会进入内部的 synchronized代码块
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                // 也许有其它线程已经创建实例，所以再判断一次
                if (INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

以上的实现特点是：

  • 懒惰实例化
  • 首次使用 getInstance() 才使用 synchronized 加锁，后续使用时无需加锁

但在多线程环境下，上面的代码是有问题的， INSTANCE = new Singleton() 对应的字节码

0: new #2 // class com/hzz/t4/Singleton 
3: dup 
4: invokespecial #3 // Method "<init>":()V 
7: putstatic #4 // Field

其中 4 和 7 两步的顺序不是固定的，也许 JVM 会优化为：先将引用地址赋值给 INSTANCE 变量后，再执行构造方法，如果两个线程 t1，t2 按如下时间序列执行

时间1 t1 线程执行到 INSTANCE = new Singleton(); 
时间2 t1 线程分配空间，为 Singleton对象生成了引用地址（0 处） 
时间3 t1 线程将引用地址赋值给 INSTANCE，这时 INSTANCE != null（7 处） 
时间4 t2 线程进入 getInstance() 方法，发现 INSTANCE != null（synchronized块外），直接 返回 INSTANCE 
时间5 t1 线程执行Singleton的构造方法（4 处）

这时 t1 还未完全将构造方法执行完毕，如果在构造方法中要执行很多初始化操作，那么 t2 拿到的是将是一个未初始化完毕的单例。


对 INSTANCE 使用 volatile 修饰即可，可以禁用指令重排，但要注意在 JDK 5 以上的版本的 volatile 才会真正有效。

🚁3.2 指令重排序优化

事实上，现代处理器会设计为一个时钟周期完成一条执行时间最长的 CPU 指令，将其再划分成为一个个更小的阶段。例如，每条指令都可以分为：取指令--指令译码--执行指令--内存访问--数据写回 这 5 个阶段。2e718f6de6d94987ae2f2182c528d9c8.png

.术语参考：

instruction fetch(IF)

instruction decode(ID)

execute(EX)

memory access(MEM)

register write back(WB)

在不改变程序结果的前提下，这些指令的各个阶段可以通过重排序和组合来实现指令级并行。

指令重排的前提是，重排指令不能影响结果，例如：

//可以重排的例子
int a = 10;  //指令1
int b = 20;  //指令2
System.out.println(a+b);
//不能重排的例子
int a = 10;  //指令1
int b = a - 5;  //指令2

🚁3.3 支持流水线的处理器

现代 CPU 支持多级指令流水线，例如支持同时执行取指令--指令译码--执行指令--内存访问--数据写回的处理器，就可以称之为五级指令流水线。这时 CPU 可以在一个时钟周期内，同时运行五条指令的不同阶段（相当于一条执行时间最长的复杂指令），IPC = 1，本质上，流水线技术并不能缩短单条指令的执行时间，但它变相地提高了指令吞吐率。2e718f6de6d94987ae2f2182c528d9c8.png

在多线程环境下，指令重排序可能导致出现意料之外的结果。

解决方法：

使用 volatile 修饰的变量，可以禁用指令重排序。

  • 禁止的是加 volatile 关键字变量之前的代码被重排序

🚀4. 内存屏障

可见性


写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中

读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中新数据

有序性


写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后

读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

🚀5. volatile 原理

volatile 的底层实现原理是内存屏障（Memory Barrier（Memory Fence）


对 volatile 变量的写指令后会加入写屏障

对 volatile 变量的读指令前会加入读屏障

🚁5.1 如何保证可见性

写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中

public void actor2(I_Result r) {
  num = 2;
  ready = true;   //ready是volatile赋值带写屏障
  //写屏障
}

而读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中新数据2e718f6de6d94987ae2f2182c528d9c8.png

🚁5.2 如何保证有序性

写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后

public void actor2(I_Result r) {
  num = 2;
  ready = true;   //ready是volatile赋值带写屏障
  //写屏障
}

读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

public void actor1(I_Result r) {
  //读屏障
  //ready是volatile读取值带读屏障
  if(ready) {
    r.r1 = num +　num;
  } else {
    r.r1 = 1;
  }
}

2e718f6de6d94987ae2f2182c528d9c8.png

但是不能解决指令交错问题

  • 写屏障仅仅是保证之后的读能够读到新的结果，但不能保证读跑到它前面去
  • 而有序性的保证也只是保证了本线程内相关代码不被重排序
文章标签：
Java
安全
缓存
编译器
关键词：
Java内存
内存模型
Java模型
java并发编程内存
Java共享
ReadThroughLife
目录
相关文章
木流牛马
|
1月前
|
安全 Java 应用服务中间件
Spring Boot + Java 21：内存减少 60%，启动速度提高 30% — 零代码
通过调整三个JVM和Spring Boot配置开关，无需重写代码即可显著优化Java应用性能：内存减少60%，启动速度提升30%。适用于所有在JVM上运行API的生产团队，低成本实现高效能。
木流牛马
187 3
艾伦~耶格尔
|
2月前
|
存储 缓存 Java
Java数组全解析：一维、多维与内存模型
本文深入解析Java数组的内存布局与操作技巧，涵盖一维及多维数组的声明、初始化、内存模型，以及数组常见陷阱和性能优化。通过图文结合的方式帮助开发者彻底理解数组本质，并提供Arrays工具类的实用方法与面试高频问题解析，助你掌握数组核心知识，避免常见错误。
艾伦~耶格尔
110 0
poemyang
|
12天前
|
Java 大数据 Go
从混沌到秩序：Java共享内存模型如何通过显式约束驯服并发？
并发编程旨在混乱中建立秩序。本文对比Java共享内存模型与Golang消息传递模型，剖析显式同步与隐式因果的哲学差异，揭示happens-before等机制如何保障内存可见性与数据一致性，展现两大范式的深层分野。（238字）
poemyang
35 4
一枚后端工程狮
|
16天前
|
存储 缓存 Java
【深入浅出】揭秘Java内存模型（JMM）：并发编程的基石
本文深入解析Java内存模型（JMM），揭示synchronized与volatile的底层原理，剖析主内存与工作内存、可见性、有序性等核心概念，助你理解并发编程三大难题及Happens-Before、内存屏障等解决方案，掌握多线程编程基石。
一枚后端工程狮
224 8
蓝易云
|
1月前
|
缓存 监控 Kubernetes
Java虚拟机内存溢出（Java Heap Space）问题处理方案
综上所述, 解决Java Heap Space溢出需从多角度综合施策; 包括但不限于配置调整、代码审查与优化以及系统设计层面改进; 同样也不能忽视运行期监控与预警设置之重要性; 及早发现潜在风险点并采取相应补救手段至关重要.
蓝易云
340 17
Deephub
|
2月前
|
人工智能 边缘计算 自然语言处理
普通电脑也能跑AI：10个8GB内存的小型本地LLM模型推荐
随着模型量化技术的发展，大语言模型（LLM）如今可在低配置设备上高效运行。本文介绍本地部署LLM的核心技术、主流工具及十大轻量级模型，探讨如何在8GB内存环境下实现高性能AI推理，涵盖数据隐私、成本控制与部署灵活性等优势。
Deephub
1211 0
普通电脑也能跑AI：10个8GB内存的小型本地LLM模型推荐
艾伦~耶格尔
|
2月前
|
存储 监控 算法
Java垃圾回收机制（GC）与内存模型
本文主要讲述JVM的内存模型和基本调优机制。
艾伦~耶格尔
179 0
啦啦啦191
|
2月前
|
边缘计算 算法 Java
Java 绿色计算与性能优化：从内存管理到能耗降低的全方位优化策略与实践技巧
本文探讨了Java绿色计算与性能优化的技术方案和应用实例。文章从JVM调优（包括垃圾回收器选择、内存管理和并发优化）、代码优化（数据结构选择、对象创建和I/O操作优化）等方面提出优化策略，并结合电商平台、社交平台和智能工厂的实际案例，展示了通过Java新特性提升性能、降低能耗的显著效果。最终指出，综合运用这些优化方法不仅能提高系统性能，还能实现绿色计算目标，为企业节省成本并符合环保要求。
啦啦啦191
106 0
我是暴发户
|
3月前
|
存储
阿里云轻量应用服务器收费标准价格表：200Mbps带宽、CPU内存及存储配置详解
阿里云香港轻量应用服务器，200Mbps带宽，免备案，支持多IP及国际线路，月租25元起，年付享8.5折优惠，适用于网站、应用等多种场景。
我是暴发户
1028 0
青云@yd
|
3月前
|
存储 缓存 NoSQL
内存管理基础：数据结构的存储方式
数据结构在内存中的存储方式主要包括连续存储、链式存储、索引存储和散列存储。连续存储如数组，数据元素按顺序连续存放，访问速度快但扩展性差；链式存储如链表，通过指针连接分散的节点，便于插入删除但访问效率低；索引存储通过索引表提高查找效率，常用于数据库系统；散列存储如哈希表，通过哈希函数实现快速存取，但需处理冲突。不同场景下应根据访问模式、数据规模和操作频率选择合适的存储结构，甚至结合多种方式以达到最优性能。掌握这些存储机制是构建高效程序和理解高级数据结构的基础。
青云@yd
307 0

热门文章

最新文章

  • 1
    百宝箱开放平台 ✖️ Java SDK
  • 2
    Java AI智能体实战：使用LangChain4j构建能使用工具的AI助手
  • 3
    JUC系列之《CompletableFuture：Java异步编程的终极武器》
  • 4
    基于JavaWeb的销售管理系统设计系统
  • 5
    告别空指针噩梦：Optional让Java代码更优雅
  • 6
    Java异常处理：程序世界的“交通规则
  • 7
    JUC系列之《深入理解AQS：Java并发锁的基石与灵魂 》
  • 8
    【深入浅出】揭秘Java内存模型（JMM）：并发编程的基石
  • 9
    《深入理解Spring》：现代Java开发的核心框架
  • 10
    Java与AI智能体：构建自主决策与工具调用的智能系统
  • 1
    阿里云服务器配置选择方法：付费类型、地域及CPU内存配置全解析
    46
  • 2
    “不要通过共享内存来通信”——深入理解Golang并发模型与CSP理论
    32
  • 3
    一把锁的两种承诺：synchronized如何同时保证互斥与内存可见性？
    74
  • 4
    从混沌到秩序：Java共享内存模型如何通过显式约束驯服并发？
    35
  • 5
    LLM 内存需求计算方式
    106
  • 6
    内存溢出与内存泄漏：解析与解决方案
    393
  • 7
    【JUC】（4）从JMM内存模型的角度来分析CAS并发性问题
    59
  • 8
    125_训练加速：FlashAttention集成 - 推导注意力优化的独特内存节省
    120
  • 9
    119_LLM训练的高效内存管理与优化技术：从ZeRO到Flash Attention
    190
  • 10
    我们来说一说 ThreadLocal 内存泄漏
    176

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Java开发手册（嵩山版）灵魂17问
  • 内存取证与IaaS云平台恶意行 为的安全监控
  • 云服务器ECS内存增强型实例re6全新发布
    • 下一篇
    一文了解：阿里云对象存储OSS是什么？