0
点赞
收藏
分享

微信扫一扫

JVM学习笔记(五)内存模型

前端王祖蓝 2024-04-23 阅读 7
jvm

1、原子性

1.1 问题分析 

举例:两个线程对初始值为 0 的静态变量一个做自增,一个做自减,各做 5000 次,结果是 0 吗?结果可能是正数、负数、零。为什么呢?因为 Java 中对静态变量的自增,自减并不是原子操
作。 

public class Demo3_1 {

    static int a = 10;

    public static void main(String[] args) {
        addTest();

    }

    public static void addTest(){
        a++;
    }
}

对于 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 的内存模型如下,完成静态变量的自增,自减需要在主存和线程内存中进行数据交换:

如果是单线程以下 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

1.2 解决方法

synchronized (同步关键字),语法:

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

用 synchronized 解决并发问题:

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);
}

优化:将synchronized提取到for循环外面,减少了加锁/解锁的次数:

        Thread t1 = new Thread(() -> {
            synchronized (obj) {
                for (int j = 0; j < 5000; j++) {
                    i++;
                }
            }
        });

2、可见性

2.1 退不出的循环

现象如下,main 线程对 run 变量的修改对于 t 线程不可见,导致了 t 线程无法停止:

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不会如预想的停下来
}

分析原因:

2.2 解决办法

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

可见性,它保证的是在多个线程之间,一个线程对 volatile 变量的修改对另一个线程可见,volatile 不能保证原子性,仅用在一个写线程,多个读线程的情况。

3、有序性

3.1 诡异的结果

int num = 0;
boolean ready = false;
// 线程1 执行此方法
public void actor1(I_Result r) {
   if(ready) {
       r.r1 = num + num;
  } else {
       r.r1 = 1;
  }
}
// 线程2 执行此方法
public void actor2(I_Result r) {
   num = 2;
   ready = true;
}

I_Result 是一个对象,有一个属性 r1 用来保存结果,问:可能的结果有几种?

  • 情况1:线程1 先执行,这时 ready = false,所以进入 else 分支结果为 1;
  • 情况2:线程2 先执行 num = 2,但没来得及执行 ready = true,线程1 执行,还是进入 else 分支,结果为1;
  • 情况3:线程2 执行到 ready = true,线程1 执行,这回进入 if 分支,结果为 4(因为 num 已经执行过了); 

但还有可能是0,这种情况下是:线程2 执行ready=true,切换到线程1,进入if分支,相加为0,再切回线程2执行num=2;这种现象叫做指令重排,是 JIT 编译器在运行时的一些优化,这个现象需要通过大量测试才能复现:借助java并发压测工具jcstress。

3.2 解决办法

volatile 修饰的变量,可以禁用指令重排。

volatile boolean ready = false;

3.3 有序性理解

static int i;
static int j;


// 在某个线程内执行如下赋值操作
i = ...; // 较为耗时的操作
j = ...;

可以看到,上面的代码不管先执行 i 还是先执行  j ,对最终的结果不会产生影响。所以,上面代码真正执行时,既可以是先i后j,也可以先j后i。JVM 会在不影响正确性的前提下,可以调整语句的执行顺序,这种特性称之为『指令重排』。多线程下『指令重排』会影响正确性,例如著名的double-checked locking模式实现单例:(使用时须加volatile)

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() 对应的字节码为:

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

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

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

3.4 

举报

相关推荐

JVM笔记----JVM内存模型

JVM五大内存模型

JVM学习-内存监控工具(五)

JVM内存模型

JVM 内存模型

jvm内存模型

0 条评论