栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

浅谈JMM&Volatile&Synchronized

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

浅谈JMM&Volatile&Synchronized

内存模型

内存模型:在特定的操作协议下,对特定的内存或者高速缓存进行读写访问的过程抽象

定义了共享内存多核系统中多线程程序读写操作行为的规范。通过实现这些规范的规则来对内存进行读写,以保证指令执行的正确性,它解决了CPU多级缓存、处理器优化、指令重排序等导致的内存访问问题

Java内模型

Java内存模型:一种符合内存模型规范的,屏蔽了各种硬件和操作系统差异(write once,run anywhere),保证Java程序在各种平台下对内存的访问都能保证效果一致的机制和规范。它的主要目的是定义程序中各种变量的访问规则,关注的是在虚拟机中如何把变量值存储到内存和从内存中取出变量值的细节(变量:特指共享的数据,而不包括局部变量等线程私有数据)

 

  • JMM规定所有的变量都存储在主存中,线程的工作内存保存了本该线程使用的变量的副本(不是将主存中的整个变量都copy一份到工作内存中,只是使用到的属性值)
  • JMM规定线程对变量的所有操作都必须在工作内存中进行,线程不能直接读写主存的数据,线程之间的工作内存相互独立,线程间的通信通过主存完成
一段经典代码:线程A执行foo方法,线程B执行bar方法,为什么有时候assert断言失败,为什么b被volatile修饰之后,断言能一直成功
int a=0;
// volatile int b = 0;
int b=0;
void foo() {
    a = 1;
    b = 1;
}
void bar() {
    while (b == 0) 
        continue;
    assert(a == 1)
}
八大指令
JMM 定义了8个指令用于实现如何把一个变量中主存拷贝到工作内存和如何把工作内存中的数据同步回主存,JVM实现时必须保证每一个指令都是原子性的
  • lock:作用于主存,把一个变量标识成被一条线程独占的状态
  • unlock:作用于主存,把处于锁定状态的变量进行释放
  • read:作用于主存,把主存变量的值从主存传输到线程的工作内存中,待load使用
  • load:作用于工作内存,将read操作从主存得到的变量值,放到线程对应的工作内存中
  • use:作用于工作内存,把工作内存中的一个变量的值传递给执行引擎,每当虚拟机遇到一个需要使用变量的值的字节码指令时就是执行use操作
  • assign(赋值):作用于工作内存,把工作内存中的一个变量的值赋给工作内存中的变量
  • store:作用于工作内存,把工作内存中变量的值传到主存中,供之后的write使用
  • write:作用于主存,把store操作传输到主存中的变量放到主存的变量中
把一个变量从主存拷贝到工作内存:read -> load
把一个变量从工作内存同步到主存:store->write

八大指令的执行要求

  • 不允许read和load、store和write操作单一出现,必须成对出现
  • 不允许先丢弃它最近的assign操作,变量在工作内存改变之后,必须把该变化同步到主存
  • 一个变量同一时刻只允许一个线程对其进行lock操作,lock操作可以被同一个线程重复执行多次(类似于可重入锁),多次lock,就需要同样次数的unlock,变量才会被解锁
  • 如果一个变量事先没有被lock操作锁定,那就不允许对它执行unlock操作,也不允许去unlock一个 被其他线程锁定的变量
  • 如果对一个变量进行lock操作,那将会清空工作内存中此变量的值,在执行引擎使用这个变量前,必须重新执行load或assign操作初始化这个变量的值(简单来说必须从主存中重新读取)
  • 对一个变量执行unlock之前,必须把此变量同步到主存中
JMM基于硬件层面提供指令实现的4个自己的内存屏障指令

屏障类型

指令实例

说明

LoadLoad

Load1;LoadLoad;Load2

确保Load1数据的装载先于Load2及其以后的装载指令的装载

StoreStore

Strores:StroeStroe;Stroe2

确保Store1数据的装载先于相比于Store2及其以后的存储指令先刷新到内存

LoadStore

Load1;LoadStore;Stroe2

确保Load1数据装载先于Store2及其以后的存储指令先刷新到内存

StoreLoad

Store1;StoreLoad;Load2

确保Store1数据对其他处理器变得可见先于Load2以及后续装载指令的装载

Volatile& Synchronized
双重检测锁
public class Singleton {
    private volatile static Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
    public static void main(String[] args) {
        Singleton.getInstance();
    }
}
字节码                                                                                                                                        -XX:CompileCommand=compileonly                                                                                       javap -v Singleton.class
public static volatile lsl.tool.efficienttest.demo.Singleton instance;
    descriptor: Llsl/tool/efficienttest/demo/Singleton;
    flags: ACC_PUBLIC, ACC_STATIC, ACC_VOLATILE

    .....

public static lsl.tool.efficienttest.demo.Singleton getInstance();
    descriptor: ()Llsl/tool/efficienttest/demo/Singleton;
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=0
         0: getstatic     #2                  // Field instance:Llsl/tool/efficienttest/demo/Singleton;
         3: ifnonnull     37
         6: ldc           #3                  // class lsl/tool/efficienttest/demo/Singleton
         8: dup
         9: astore_0
        10: monitorenter
        11: getstatic     #2                  // Field instance:Llsl/tool/efficienttest/demo/Singleton;
        14: ifnonnull     27
        17: new           #3                  // class lsl/tool/efficienttest/demo/Singleton
        20: dup
        21: invokespecial #4                  // Method "":()V
        24: putstatic     #2                  // Field instance:Llsl/tool/efficienttest/demo/Singleton;
        27: aload_0
        28: monitorexit
        29: goto          37
        32: astore_1
        33: aload_0
        34: monitorexit
        35: aload_1
        36: athrow
        37: getstatic     #2                  // Field instance:Llsl/tool/efficienttest/demo/Singleton;
        40: areturn
hotspot>bytecodeInterpreter.cpp

 

// Now store the result
int field_offset = cache->f2_as_index(); 
// 判断变量是否加了ACC_VOLATILE标记
if (cache->is_volatile()) {
    if (tos_type == itos) {
        obj->release_int_field_put(field_offset, STACK_INT(-1));
    } else if (tos_type == atos) {
        VERIFY_OOP(STACK_OBJECT(-1));
        obj->release_obj_field_put(field_offset, STACK_OBJECT(-1));
        OrderAccess::release_store(&BYTE_MAP_BASE[(uintptr_t)obj >>
        CardTableModRefBS::card_shift], 0);
    } else if (tos_type == btos) {
        obj->release_byte_field_put(field_offset, STACK_INT(-1));
    } else if (tos_type == ltos) {
        obj->release_long_field_put(field_offset, STACK_LONG(-1));
    } else if (tos_type == ctos) {
        obj->release_char_field_put(field_offset, STACK_INT(-1));
    } else if (tos_type == stos) {
        obj->release_short_field_put(field_offset, STACK_INT(-1));
    } else if (tos_type == ftos) {
        obj->release_float_field_put(field_offset, STACK_FLOAT(-1));
    } else {
        obj->release_double_field_put(field_offset, STACK_DOUBLE(-1));
    }
    // storeload内存屏障
    OrderAccess::storeload();
}
orderAccess.cpp                                                                                                                      JMM屏蔽不同底层系统的区别的体现所在,针对于不同的操作系统、CPU架构,有不同的屏障指令实现

orderAccess_linux_x86.inline.hpp

 

inline void OrderAccess::loadload()   { acquire(); }
inline void OrderAccess::storestore() { release(); }
inline void OrderAccess::loadstore()  { acquire(); }
inline void OrderAccess::storeload()  { fence(); }

inline void OrderAccess::acquire() {
  volatile intptr_t local_dummy;
#ifdef AMD64
  __asm__ volatile ("movq 0(%%rsp), %0" : "=r" (local_dummy) : : "memory");
#else
  __asm__ volatile ("movl 0(%%esp),%0" : "=r" (local_dummy) : : "memory");
#endif // AMD64
}

inline void OrderAccess::release() {
  // Avoid hitting the same cache-line from
  // different threads.
  volatile jint local_dummy = 0;
}

inline void OrderAccess::fence() {
  if (os::is_MP()) {
    // 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
  }
}
对instance赋值的汇编代码

 

0x01a3de0f: mov $0x3375cdb0,%esi ;...beb0cd75 33 
                                    ; {oop('Singleton')} 
0x01a3de14: mov %eax,0x150(%esi) ;...89865001 0000 
0x01a3de1a: shr $0x9,%esi ;...c1ee09 
0x01a3de1d: movb $0x0,0x1104800(%esi) ;...c6860048 100100 
0x01a3de24: lock addl $0x0,(%esp) ;...f0830424 00 
                                     ;*putstatic instance 
                                     ; - Singleton::getInstance@24 

 

New Object过程                                                                                                                        根据as-if-serial,只要单线程情况下执行结果是正确的,指令可以任意排序,所以这里的步骤2和3是可以进行重排的
memory = allocate();  // 1:分配对象的内存空间 
ctorInstance(memory); // 2:初始化对象 
instance = memory;  // 3:设置instance指向刚分配的内存地址
Volatile

可见性
  1. volatile修饰的变量的操作会加上对应的内存屏障指令(没有直接用lock指令),产生的效果就是当变量被修改之后,能使修改后的值从高速缓存中同步到主存,并使其他寄存器中的该变量缓存值失效
有序性
  1. JMM对Volatile的特殊操作,使用了CPU架构层面的内存屏障指令,而内存屏障指令的作用就是将在此命令之前的处理器缓存全部同步到主存,也就说在内存屏障之前的指令一定会比屏障指令后的先执行完成,从而禁止了指令重排序

Synchronized

通过JMM指令基本数据类型的访问、读写都是具备原子性的,但是为了实现更大的范围的原子性操作,JMM提供了lock和unlock指令,虚拟机未把lock和unlock操作直接开放给用户使用,但是却提供了更 高层次的字节码指令monitorenter和monitorexit来隐式地使用这两个操作。这两个字节码指令反映到Java 代码中就是同步块——synchronized关键字,因此在synchronized块之间的操作也具备原子性(这里直接把monitorenter当lock指令,monitorexit当unlock指令解释)

原子性
  1. 一个对象在同一时刻别一个线程进行lock操作,并且进行lock操作时必须重新从主存中同步共享变量的值
  2. 线程对对象进行lock之后,其他线程不能进行lock操作
可见性
  1. 对一个变量执行unlock操作之前,必须先把此变量同步回主内存中(执行store、write操作)
有序性
  1. 一个变量在同一个时刻只允许一条线程对其进行lock操作,决定了持有同一个锁的两个同步块只能串行地进入
  2. 将代码块看成一个原子性操作,代码块之前的操作在这个操作之前执行完,但是Synchronized并不能够防止代码块内部进行指令重排(双重检测锁单例模式使用volatile的原因)

ps:在双重检测锁的字节码中之所以会有两个monitorexit操作,因为JVM要求加锁之后必须要释放锁,第一个monitorexit是正常释放锁操作,第二个是为了防止代码块执行出现异常,也能够进行释放锁

ps:为什么没有贴synchronized相关的hotspot源码与汇编代码,因为没看懂源码的意思以及汇编代码实在是太长了,建议可以去找相关的博客(HotSpot synchronized原理_SherlockCharlie的博客-CSDN博客)

Happens-before

并不是所有的代码都会出现指令重排的情况,只要符合Happens-before(先行先发原则),就天然满足有序性

int a = 0;
int b = 1;
void test(){
    a = 1;
    b = 2;
    int c = a*b;
}
  • 规则1-程序次序原则(as-if-serial):如果两个指令存在依赖关系,是不允许重排序,反之,如果两个指令重排序不影响单线程执行结果,那就可能发生重排
  • 规则2-传递性:操作A先行发生与操作B,操作B先行发生与操作C,则A先行发生与C
  • 规则3-volatile变量规则:对一个volatile变量的写操作先行发生与对volatile变量的读操作(内存屏障防止指令重排)
  • .......
volatile重排序规则表

是否能重排序

第二个操作

第一个操作

普通读/写

volatile读

volatile写

普通读/写

NO

volatile写

NO

NO

volatile读

NO

NO

NO

总结 为什么需要JMM
  1. 不同的cpu架构,对内存的读写方式、对内存屏障的支持不同,对应的指令也有不同
  2. Java要实现Write once Run anywhere,于是有了JMM,JVM依靠JMM实现在各种平台下对能够保证Java程序对内存的访问都能效果一致
  3. Java要保证多线程的安全性
CPU层面为什么会提供内存屏障指令 参考文档

深入理解Java虚拟机(第3版)

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/970316.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号