HotSpot虚拟机之内存模型与线程安全

目录

一、线程内存模型

1. 内存模型

2. 内存模型操作

二、Happens-Before原则

三、Java线程

1. 线程实现方式

2. Java线程状态

四、Java线程安全

1. 线程安全程度

2. 锁优化

五、参考资料


一、线程内存模型

1. 内存模型

        内存模型主要目的是定义共享变量的访问规则,共享变量如:实例字段、静态字段、数组元素等线程共享变量(不包含线程私有变量)。内存模型中有:主内存、工作内存,如下图所示是两者交互关系,看出主内存直接对应于物理硬件的内存,而程序运行时主要访问的是工作内存

  • 主内存(Main Memory):内存模型规定所有变量都存储在主内存中
  • 工作内存(Working Memory):每个线程都有自己的内存,且变量是主内存的副本

        线程对变量的操作只能在工作内存,无法直接读写主内存;线程之间变量传递必须通过主内存实现,模型如下图所示。

        注意:内存模型与内存区域划分没有任何关系,若勉强有关系,则:主内存对应堆对象实例,工作内存对应JVM栈的部分区域。

2. 内存模型操作

        内存模型操作,即:主内存与工作内存交互,定义了8种原子性操作:lock、unlock、read、load、use、assign、store、write,如下表所示。

内存模型操作

特点

lock

(锁定)

范围:主内存变量;

作用:把变量标识为一个线程独占的状态。

unlock

(解锁)

范围:主内存变量;

作用:释放处于锁定状态的变量,后才能被其他线程锁定。

read

(读取)

范围:主内存变量;

作用:把变量的值从主内存传输到线程工作内存中,以便后续load操作。

load

(载入)

范围:工作内存变量;

作用:把read操作获取的变量值存储到工作内存的变量副本中

use

(使用)

范围:工作内存变量;

作用:把变量的值传递给执行引擎(每遇到使用该变量的字节码指令)。

assign

(赋值)

范围:工作内存变量;

作用:把执行引擎接收到的值赋给工作内存的变量

      (每遇到给变量赋值的字节码指令)。

store

(存储)

范围:工作内存变量;

作用:把变量的值从工作内存传输到主内存中,以便后续write操作。

write

(写入)

范围:主内存变量;

作用:把store操作获取的变量值存储到主内存中。

注意:

    a.一个变量从主内存复制到工作内存:必须顺序执行read、load操作,但可以不连续执行

       一个变量从工作内存同步到主内存:必须顺序执行store、write操作,但可以不连续执行

    b.8种操作满足以下规则:

       1):read和load、store和write不允许单独出现,即:不会出现回写主内存但其不接受;

       2):不允许线程丢弃最近的assign,即:工作内存值改变,则必须同步到主内存;

       3):不允许线程不原因的同步到主内存,即:不允许没有assign操作就同步到主内存;

       4):一个新变量主内存诞生,即:对变量进行use、store时,则必须先执行assign、load;

       5):同一时刻只有一个线程对变量lock(同一线程多次lock,则必须多次unlock后才释放);

       6):执行lock时,则必须清空工作内存中此变量的副本值,后使用时重新执行load、assign;

       7):执行unlock之前,则必须把此变量同步到主内存中;

    c.Java内存模型操作简化为:read、write、lock、unlock的四种操作

        从上表看出,内存模型主要围绕并发过程中如何处理原子性、可见性、有序性建立的,这三大特性如下图所示。

        注意:只有一条字节码指令也不意味着是原子性,解释器要运行多行代码才能实现其语义;volatile修饰的变量具有特性:可见性、禁止指令重排序;"long和double的非原子协定":没有volatile修饰的64位数据的读写操作划分为两次32位操作,但一般认为是原子操作(概率极低)。 

二、Happens-Before原则

        Happens-Before原则(先行发生原则)定义两操作之间的偏序关系,因此并发安全问题不要受时间顺序影响,一切按先行发生原则为准。无需任何同步手段保证先行发生规则,如下表所示。

先行发生原则

特点

程序次序规则

同一个线程内,按照控制流顺序,在前的操作先行发生于其后的操作

管程锁定规则

释放锁操作先行发生于同一个锁的加锁操作

volatile变量规则

volatile变量写操作先行发生于读操作

线程启动规则

Thread线程start()方法先行发生于此线程的每一个动作

线程终止规则

线程中所有操作先行发生于对此线程的终止检查

线程中断规则

线程interrupt()方法调用先行发生于被中断代码检查到中断时间的发生

对象终结规则

对象构造函数完成先行发生于它的finalize()方法的开始

传递性

操作A先行发生于操作B,操作B先行发生于操作C,则A先行发生于C

三、Java线程

1. 线程实现方式

        线程是轻量级进程,各个线程共享进程资源(内存地址、I/O等)、又可以独立调度,把一个进程的资源分配和执行调用分开。实现线程有3种方式:内核线程实现(1:1)、用户线程实现(N:1)、混合实现(M:N),如下表所示。

线程实现

特点

内核线程实现

(1:1)

1.“内核线程”:直接由OS内核完成,内核完成线程切换,操纵调度器对线程调度,并负责将线程的任务映射到各个CPU上(每个内核线程可以视为内核的一个分身)

2.每个轻量级进程(线程)都有一个内核线程支持,即:1:1实现

3.缺点:

   a.系统调用代价大,需要在用户态与内核态来回切换;

   b.OS支持轻量级进程的数量有限;

4.Java线程采用内核线程实现

用户线程实现

(N:1)

1.“用户线程”:线程非内核线程,线程的创建、同步、销毁及调度在用户态中完成无需内核的帮助,映射到一个CPU上,即:N:1实现

2.优点:无需切换到内核,因此速度快、低耗;更大规模的线程数;

  缺点:线程调度实现复杂;增大线程被阻塞的风险。

混合实现

(M:N)

内核和用户线程混合使用,用户负责线程的创建、同步、销毁;内核线程负责线程调度

        Java线程实现方式采用内核线程实现,每一个java线程都直接映射到一个内核线程上,HotSpot不会干涉线程的调度

        线程调度(Scheduler)是指线程分配处理器使用权的过程,两种调度方式:协同式(协程)、抢占式(java采用),如下表所示。

实现方式

特点

协同式线程调度 - 协程

(Cooperative Threads-Scheduling)

1.线程执行时间由线程本身控制,线程工作执行完后,主动通知系统切换到另外的线程上

2.优点:切换操作对线程可知;实现简单;

   缺点:线程执行时间不可控,若代码有问题,则一直阻塞

3.应用:Lua语言的“协同例程”。

抢占式线程调度 - Java采用

(Preemptive Threads-Scheduling)

1.线程执行时间由系统来分配执行时间,如:Thread::yeild()方法可以主动让出时间,但无法主动获取执行时间

2.通过线程优先级可以“建议”OS多分配执行时间,但是不能稳定,最终还是OS决定。

        Java线程调度方式采用抢占式线程调度,因此Java中不能通过线程优先级完全准确判定一组Ready状态的线程会先执行哪一个。而Thread类大部分API都是Native修饰,而Native往往是该方法没有使用或无法使用平台无关的手段来实现

2. Java线程状态

        Java线程状态有6种状态:新建、运行(Runnable = Running + Ready)、无限期等待、限期等待、阻塞、结束,如下表所示。

线程状态

特点

新建

(New)

创建后但尚未启动,即:new之后,start()之前

运行

(Running + Ready)

包含两种状态:正在运行Running、正在等待系统分配执行时间Ready

无限期等待

(Waiting)

1.处于:线程不会被分配处理器执行时间,需被其他线程显示唤醒

2.方法有:

   没有设置timeout参数的Object::wait(),若加锁会释放锁;

   没有设置timeout参数的Object::join();

   LockSupport::park()。

限期等待

(Timed Waiting)

1.处于:线程不会被分配处理器执行时间,无需被其他线程显示唤醒,在一定时间之后系统会自动唤醒

2.方法有:

   Thread::sleep(),若加锁不会释放锁

   设置timeout参数的Object::wait(),若加锁会释放锁

   设置timeout参数的Object::join();

   LockSupport::parkNanos()、LockSupport::parkUntil()。

阻塞

(Blocked)

1.处于:线程被阻塞,需等待获取排他锁

2.“阻塞状态”与“等待状态”的区别:

   阻塞状态:需等待获取排他锁,建立在另一线程释放锁之上;

   等待状态:等待一段时间或唤醒动作的发生

结束

(Terminated)

已终止线程的状态

        任意时间点,线程有且只有其中一种状态,6种状态之间切换关系如下图所示。

四、Java线程安全

1. 线程安全程度

        多线程访问同一对象,不用考虑线程运行环境时的调度和交替执行,也不使用同步手段或调用方不进行协调操作时,使用该对象都能获取正确的结果,则称该对象是线程安全的。根据安全层度分为5种(依次降低):不可变、绝对线程安全、相对线程安全、线程兼容、线程对立,如下表所示。

线程安全程度

特点

不可变

1.不可变的共享对象,一定是线程安全的,无论是对象的方法还是调用者;

2.共享数据是基本数据类型,用final修饰来保证不可变

   共享数据是对象数据类型,需要对象自行保证自己的行为对其不受任何影响,如:String对象的substring()、replace()、concat()不会影响原值,只返回一个新构造的字符串对象

3.不可变对象有:final修饰的基本类型、String、AtomicInteger、AtomicLong。

绝对线程安全

1.“绝对安全”:不管运行如何,调用者都无需任何额外的同步手段

2.Java中绝大多数都不是绝对安全,而是相对安全。

相对线程安全

1.“相对安全”:对象单次操作是线程安全的,调用时无需额外的同步手段;

2.若是连续调用,则需要调用端额外的同步手段

3.相对线程安全类:Vector、HashTable等。

线程兼容

1.“线程兼容”:对象本身不是线程安全,需要调用端额外的同步手段

2.线程兼容的类:ArrayList、HashMap等

线程对立

1.“线程对立”:无论是否同步,都无法在多线程环境并发使用

2.Java天生支持多线程特性,应避免尽可能避免线程对立,会出现死锁。

        注意:线程安全是以多线程之间存在共享数据为前提;不可变对象,如:String对象的substring()、replace()、concat()不影响原值,只返回一个新构造的字符串对象

        现实线程安全有3种方式:互斥同步(阻塞同步)、非阻塞同步、无同步,如下表所示。

线程安全现实

特点

互斥同步

(阻塞同步)

1.“同步”:多线程并发访问时,保证共享数据同一时刻只能被一个线程使用

2.互斥是实现同步的手段,如:互斥量、信号量、临界区等手段;

3.sychronized(重量级)实现互斥(monitorenter、monitorexit两指令完成):

   a.当前线程持有锁后,锁计数器+1;而monitorexit则锁计数器减一,直到计数器为0时,才释放锁

   b.可重入,即:同一线程反复进入同步块不会出现自锁现象

   c.当前持有锁线程没有释放锁之前,其他线程无条件的被阻塞;

4.Lock接口(轻量级):

   a.必须在finally块中手动释放锁;

   b.获取锁时,可以超时中断;

   c.可以实现公平锁、非公平锁;

   d.锁绑定多个条件;

5.互斥同步属于悲观的并发策略

6.缺点:线程阻塞和唤醒带来的性能开销。

非阻塞同步

1.基于冲突检查的乐观并发策略,共享数据检查到冲突,进行补偿措施(如重试)达到一致,不需要其他线程挂起

2.常用处理器指令集:比较并交换(CAS_常用)、交换Swap等;

3.CAS:x86指令集使用cmpxchg完成CAS;“ABA问题”,解决:时间戳控制版本。

无同步

1.线程安全的代码无需同步,如:可重入代码、ThreadLocal;

2.“可重入代码”:代码执行的任何时候中断,去执行另一段代码,而控制权返回时原程序不会出现任何错误和对结果的影响;

3.所有可重入代码是线程安全的;但是线性安全的代码不一定是可重入代码。

        注意:sychronized可重入,即:同一线程反复进入同步块不会出现自锁现象,当前持有锁线程没有释放锁之前,其他线程无条件的被阻塞;JDK5后类库使用CAS操作(Unsafe类完成)但是用户无法使用CAS;JDK9后VarHandle类开放面向程序使用CAS

2. 锁优化

        JDK6各种锁优化技术:自旋锁、自适应自旋锁、锁消除、锁粗化、轻量级锁、偏向锁,如下表所示。

锁优化

特点

自旋锁

1.“自旋锁”:等待获取锁的阻塞线程,执行忙循环(自旋),而不是切换线程

2.自旋等待避免线程切换的开销,但是占用CPU处理时间,因此:自旋超出限定次数仍没有成功,则线程挂起

3.开启自旋-XX:+UseSpining(JDK6默认开启);自旋次数-XX:PreBlockSpin(10次)。

自适应自旋锁

1.“自适应”:自旋次数不固定,由前一次在同一锁对象的自旋时间及锁状态决定

2.自旋等待成功获取锁,且持有锁线程正在运行,那么自旋可以多等待相对更长时间;若是自旋很少能成功获得锁,则以后获取这个锁时可能直接省掉自旋过程。

锁消除

1.“锁消除”:即时编译在运行时,一些同步代码被检测到不存在共享数据竞争的锁,则进行锁消除

2.锁消除判定依据是逃逸分析数据支持(堆数据不会被其他线程访问)。

锁粗化

1.“锁粗化”:连续操作都对同一对象加锁,则把加锁同步的范围扩展(粗化)到整个操作的外部

2.适用:连续StringBuffer::append()、循环体中加锁。

轻量级锁

1.“轻量级锁”:两线程竞争同一把锁;两条以上线程竞争同一把锁,则轻量级锁(非阻塞同步 _ CAS)膨胀为重量级锁(互斥同步);

2.轻量级加锁工作过程:

   step1:程序进入同步代码块时,判定对象是否被锁定(锁标志位01状态);

   step2:没有被锁定,则在当前栈帧中创建锁记录(Lock Record)空间,用于存储锁对象目前的“Mark Word”的拷贝

   step3:CAS操作把对象的“Mark Word”更新为锁记录(Lock Record)空间地址

   step4:更新成功则当前线程加锁成功,且锁标志位改为00状态;

               更新失败(说明至少存在另一线程产生相互竞争),首先检查“Mark Word”是否指向当前线程的栈帧,若是则说明当前已经持有锁,直接进入代码块;否则被其他线程线程已加锁

   step5:存在两条以上线程竞争加锁,则轻量级锁膨胀为重量级锁(锁标志位10状态),后续线程进入阻塞状态。

偏向锁

1.“偏向锁”:锁无竞争的情况下把整个同步消除掉,即:持有偏向锁的线程无需同步操作

2.进入偏向锁模式:锁标志位01状态 + 偏向模式设置为1;一旦有其他线程尝试获取锁,则:偏向模式结束、锁定对象是否处于锁定状态决定是否撤销偏向锁(偏向模式设置为0)、标志位转为01(未锁定)或00(轻量级锁)状态;

3.JDK6启用偏向锁-XX:+UseBiasedLocking。

        偏向锁、轻量级锁的状态转换及对象Mark Word的关系,如下图所示。

五、参考资料

Java线程<一> _ 介绍_爱我所爱0505的博客-CSDN博客

volatile与synchronized实现原理_synchronized底层是总线锁吗_爱我所爱0505的博客-CSDN博客

Java内存模型<一> _ 基础_爱我所爱0505的博客-CSDN博客

Java内存模型<二> _ volatile/synchronized/final内存语义_volitale final sync_爱我所爱0505的博客-CSDN博客

Java线程<三> _ 线程间通信_java 三个线程间通信_爱我所爱0505的博客-CSDN博客

Lock锁<一> _ 基础_在lock锁的队列中,什么时候前一个节点会唤醒后一个节点_爱我所爱0505的博客-CSDN博客

Lock锁<二> _ 重入锁/读写锁_读写锁可重入锁_爱我所爱0505的博客-CSDN博客

深入理解Java内存模型(一)——基础_Java_程晓明_InfoQ精选文章

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值