多线程与Java的JMM内存模型
共享内存模型指的就是Java内存模型(简称JMM),JMM决定一个线程对共享变量的写入时,能对另一个线程可见。从抽象的角度来看,JMM定义了线程和主内存之间的抽象关系:线程之间的共享变量存储在主内存(main memory)中,每个线程都有一个私有的本地内存(local memory),本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念,并不真实存在。它涵盖了缓存,写缓冲区,寄存器以及其他的硬件和编译器优化。
从上图来看,线程A与线程B之间如要通信的话,必须要经历下面2个步骤:
1. 首先,线程A把本地内存A中更新过的共享变量刷新到主内存中去。
2. 然后,线程B到主内存中去读取线程A之前已更新过的共享变量。
下面通过示意图来说明这两个步骤:
如上图所示,本地内存A和B有主内存中共享变量x的副本。假设初始时,这三个内存中的x值都为0。线程A在执行时,把更新后的x值(假设值为1)临时存放在自己的本地内存A中。当线程A和线程B需要通信时,线程A首先会把自己本地内存中修改后的x值刷新到主内存中,此时主内存中的x值变为了1。随后,线程B到主内存中去读取线程A更新后的x值,此时线程B的本地内存的x值也变为了1。
从整体来看,这两个步骤实质上是线程A在向线程B发送消息,而且这个通信过程必须要经过主内存。JMM通过控制主内存与每个线程的本地内存之间的交互,来为java程序员提供内存可见性保证。
总结:什么是Java内存模型:java内存模型简称jmm,定义了一个线程对另一个线程可见。共享变量存放在主内存中,每个线程都有自己的本地内存,当多个线程同时访问一个数据的时候,可能本地内存没有及时刷新到主内存,所以就会发生线程安全问题。
补充转载
在并发编程中,多个线程之间采取什么机制进行通信(信息交换),什么机制进行数据的同步?
在Java语言中,采用的是共享内存模型来实现多线程之间的信息交换和数据同步的。
线程之间通过共享程序公共的状态,通过读-写内存中公共状态的方式来进行隐式的通信。同步指的是程序在控制多个线程之间执行程序的相对顺序的机制,在共享内存模型中,同步是显式的,程序员必须显式指定某个方法/代码块需要在多线程之间互斥执行。
在说Java内存模型之前,我们先说一下Java的内存结构,也就是运行时的数据区域:
Java虚拟机在执行Java程序的过程中,会把它管理的内存划分为几个不同的数据区域,这些区域都有各自的用途、创建时间、销毁时间。
aaarticlea/png;base64,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" alt="" />
Java运行时数据区分为下面几个内存区域:
1.PC寄存器/程序计数器:
严格来说是一个数据结构,用于保存当前正在执行的程序的内存地址,由于Java是支持多线程执行的,所以程序执行的轨迹不可能一直都是线性执行。当有多个线程交叉执行时,被中断的线程的程序当前执行到哪条内存地址必然要保存下来,以便用于被中断的线程恢复执行时再按照被中断时的指令地址继续执行下去。为了线程切换后能恢复到正确的执行位置,每个线程都需要有一个独立的程序计数器,各个线程之间计数器互不影响,独立存储,我们称这类内存区域为“线程私有”的内存,这在某种程度上有点类似于“ThreadLocal”,是线程安全的。
2.Java栈 Java Stack:
Java栈总是与线程关联在一起的,每当创建一个线程,JVM就会为该线程创建对应的Java栈,在这个Java栈中又会包含多个栈帧(Stack Frame),这些栈帧是与每个方法关联起来的,每运行一个方法就创建一个栈帧,每个栈帧会含有一些局部变量、操作栈和方法返回值等信息。每当一个方法执行完成时,该栈帧就会弹出栈帧的元素作为这个方法的返回值,并且清除这个栈帧,Java栈的栈顶的栈帧就是当前正在执行的活动栈,也就是当前正在执行的方法,PC寄存器也会指向该地址。只有这个活动的栈帧的本地变量可以被操作栈使用,当在这个栈帧中调用另外一个方法时,与之对应的一个新的栈帧被创建,这个新创建的栈帧被放到Java栈的栈顶,变为当前的活动栈。同样现在只有这个栈的本地变量才能被使用,当这个栈帧中所有指令都完成时,这个栈帧被移除Java栈,刚才的那个栈帧变为活动栈帧,前面栈帧的返回值变为这个栈帧的操作栈的一个操作数。
由于Java栈是与线程对应起来的,Java栈数据不是线程共有的,所以不需要关心其数据一致性,也不会存在同步锁的问题。
在Java虚拟机规范中,对这个区域规定了两种异常状况:如果线程请求的栈深度大于虚拟机所允许的深度,将抛出StackOverflowError异常;如果虚拟机可以动态扩展,如果扩展时无法申请到足够的内存,就会抛出OutOfMemoryError异常。在Hot Spot虚拟机中,可以使用-Xss参数来设置栈的大小。栈的大小直接决定了函数调用的可达深度。
3.堆 Heap:
堆是JVM所管理的内存中国最大的一块,是被所有Java线程锁共享的,不是线程安全的,在JVM启动时创建。堆是存储Java对象的地方,这一点Java虚拟机规范中描述是:所有的对象实例以及数组都要在堆上分配。Java堆是GC管理的主要区域,从内存回收的角度来看,由于现在GC基本都采用分代收集算法,所以Java堆还可以细分为:新生代和老年代;新生代再细致一点有Eden空间、From Survivor空间、To Survivor空间等。
4.方法区Method Area:
方法区存放了要加载的类的信息(名称、修饰符等)、类中的静态常量、类中定义为final类型的常量、类中的Field信息、类中的方法信息,当在程序中通过Class对象的getName.isInterface等方法来获取信息时,这些数据都来源于方法区。方法区是被Java线程锁共享的,不像Java堆中其他部分一样会频繁被GC回收,它存储的信息相对比较稳定,在一定条件下会被GC,当方法区要使用的内存超过其允许的大小时,会抛出OutOfMemory的错误信息。方法区也是堆中的一部分,就是我们通常所说的Java堆中的永久区 Permanet Generation,大小可以通过参数来设置,可以通过-XX:PermSize指定初始值,-XX:MaxPermSize指定最大值。
5.常量池Constant Pool:
常量池本身是方法区中的一个数据结构。常量池中存储了如字符串、final变量值、类名和方法名常量。常量池在编译期间就被确定,并保存在已编译的.class文件中。一般分为两类:字面量和应用量。字面量就是字符串、final变量等。类名和方法名属于引用量。引用量最常见的是在调用方法的时候,根据方法名找到方法的引用,并以此定为到函数体进行函数代码的执行。引用量包含:类和接口的权限定名、字段的名称和描述符,方法的名称和描述符。
6.本地方法栈Native Method Stack:
本地方法栈和Java栈所发挥的作用非常相似,区别不过是Java栈为JVM执行Java方法服务,而本地方法栈为JVM执行Native方法服务。本地方法栈也会抛出StackOverflowError和OutOfMemoryError异常。
主内存和工作内存:
Java内存模型的主要目标是定义程序中各个变量的访问规则,即在JVM中将变量存储到内存和从内存中取出变量这样的底层细节。此处的变量与Java编程里面的变量有所不同步,它包含了实例字段、静态字段和构成数组对象的元素,但不包含局部变量和方法参数,因为后者是线程私有的,不会共享,当然不存在数据竞争问题(如果局部变量是一个reference引用类型,它引用的对象在Java堆中可被各个线程共享,但是reference引用本身在Java栈的局部变量表中,是线程私有的)。为了获得较高的执行效能,Java内存模型并没有限制执行引起使用处理器的特定寄存器或者缓存来和主内存进行交互,也没有限制即时编译器进行调整代码执行顺序这类优化措施。
JMM规定了所有的变量都存储在主内存(Main Memory)中。每个线程还有自己的工作内存(Working Memory),线程的工作内存中保存了该线程使用到的变量的主内存的副本拷贝,线程对变量的所有操作(读取、赋值等)都必须在工作内存中进行,而不能直接读写主内存中的变量(volatile变量仍然有工作内存的拷贝,但是由于它特殊的操作顺序性规定,所以看起来如同直接在主内存中读写访问一般)。不同的线程之间也无法直接访问对方工作内存中的变量,线程之间值的传递都需要通过主内存来完成。
aaarticlea/png;base64,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" alt="" />
线程1和线程2要想进行数据的交换一般要经历下面的步骤:
1.线程1把工作内存1中的更新过的共享变量刷新到主内存中去。
2.线程2到主内存中去读取线程1刷新过的共享变量,然后copy一份到工作内存2中去。
Java内存模型是围绕着并发编程中原子性、可见性、有序性这三个特征来建立的,那我们依次看一下这三个特征:
原子性(Atomicity):一个操作不能被打断,要么全部执行完毕,要么不执行。在这点上有点类似于事务操作,要么全部执行成功,要么回退到执行该操作之前的状态。
基本类型数据的访问大都是原子操作,long 和double类型的变量是64位,但是在32位JVM中,32位的JVM会将64位数据的读写操作分为2次32位的读写操作来进行,这就导致了long、double类型的变量在32位虚拟机中是非原子操作,数据有可能会被破坏,也就意味着多个线程在并发访问的时候是线程非安全的。
下面我们来演示这个32位JVM下,对64位long类型的数据的访问的问题:
public class NotAtomicity {
//静态变量t
public static long t = 0;
//静态变量t的get方法
public static long getT() {
return t;
}
//静态变量t的set方法
public static void setT(long t) {
NotAtomicity.t = t;
}
//改变变量t的线程
public static class ChangeT implements Runnable{
private long to;
public ChangeT(long to) {
this.to = to;
}
public void run() {
//不断的将long变量设值到 t中
while (true) {
NotAtomicity.setT(to);
//将当前线程的执行时间片段让出去,以便由线程调度机制重新决定哪个线程可以执行
Thread.yield();
}
}
}
//读取变量t的线程,若读取的值和设置的值不一致,说明变量t的数据被破坏了,即线程不安全
public static class ReadT implements Runnable{ public void run() {
//不断的读取NotAtomicity的t的值
while (true) {
long tmp = NotAtomicity.getT();
//比较是否是自己设值的其中一个
if (tmp != 100L && tmp != 200L && tmp != -300L && tmp != -400L) {
//程序若执行到这里,说明long类型变量t,其数据已经被破坏了
System.out.println(tmp);
}
////将当前线程的执行时间片段让出去,以便由线程调度机制重新决定哪个线程可以执行
Thread.yield();
}
}
}
public static void main(String[] args) {
new Thread(new ChangeT(100L)).start();
new Thread(new ChangeT(200L)).start();
new Thread(new ChangeT(-300L)).start();
new Thread(new ChangeT(-400L)).start();
new Thread(new ReadT()).start();
}
}
我们创建了4个线程来对long类型的变量t进行赋值,赋值分别为100,200,-300,-400,有一个线程负责读取变量t,如果正常的话,读取到的t的值应该是我们赋值中的一个,但是在32的JVM中,事情会出乎预料。如果程序正常的话,我们控制台不会有任何的输出,可实际上,程序一运行,控制台就输出了下面的信息:
-4294967096
4294966896
-4294967096
-4294967096
4294966896
之所以会出现上面的情况,是因为在32位JVM中,64位的long数据的读和写都不是原子操作,即不具有原子性,并发的时候相互干扰了。
32位的JVM中,要想保证对long、double类型数据的操作的原子性,可以对访问该数据的方法进行同步,就像下面的:
public class Atomicity {
//静态变量t
public static long t = 0;
//静态变量t的get方法,同步方法
public synchronized static long getT() {
return t;
}
//静态变量t的set方法,同步方法
public synchronized static void setT(long t) {
Atomicity.t = t;
}
//改变变量t的线程
public static class ChangeT implements Runnable{
private long to;
public ChangeT(long to) {
this.to = to;
}
public void run() {
//不断的将long变量设值到 t中
while (true) {
Atomicity.setT(to);
//将当前线程的执行时间片段让出去,以便由线程调度机制重新决定哪个线程可以执行
Thread.yield();
}
}
}
//读取变量t的线程,若读取的值和设置的值不一致,说明变量t的数据被破坏了,即线程不安全
public static class ReadT implements Runnable{ public void run() {
//不断的读取NotAtomicity的t的值
while (true) {
long tmp = Atomicity.getT();
//比较是否是自己设值的其中一个
if (tmp != 100L && tmp != 200L && tmp != -300L && tmp != -400L) {
//程序若执行到这里,说明long类型变量t,其数据已经被破坏了
System.out.println(tmp);
}
////将当前线程的执行时间片段让出去,以便由线程调度机制重新决定哪个线程可以执行
Thread.yield();
}
}
}
public static void main(String[] args) {
new Thread(new ChangeT(100L)).start();
new Thread(new ChangeT(200L)).start();
new Thread(new ChangeT(-300L)).start();
new Thread(new ChangeT(-400L)).start();
new Thread(new ReadT()).start();
}
}
这样做的话,可以保证对64位数据操作的原子性。
可见性:一个线程对共享变量做了修改之后,其他的线程立即能够看到(感知到)该变量这种修改(变化)。
Java内存模型是通过将在工作内存中的变量修改后的值同步到主内存,在读取变量前从主内存刷新最新值到工作内存中,这种依赖主内存的方式来实现可见性的。
无论是普通变量还是volatile变量都是如此,区别在于:volatile的特殊规则保证了volatile变量值修改后的新值立刻同步到主内存,每次使用volatile变量前立即从主内存中刷新,因此volatile保证了多线程之间的操作变量的可见性,而普通变量则不能保证这一点。
除了volatile关键字能实现可见性之外,还有synchronized,Lock,final也是可以的。
使用synchronized关键字,在同步方法/同步块开始时(Monitor Enter),使用共享变量时会从主内存中刷新变量值到工作内存中(即从主内存中读取最新值到线程私有的工作内存中),在同步方法/同步块结束时(Monitor Exit),会将工作内存中的变量值同步到主内存中去(即将线程私有的工作内存中的值写入到主内存进行同步)。
使用Lock接口的最常用的实现ReentrantLock(重入锁)来实现可见性:当我们在方法的开始位置执行lock.lock()方法,这和synchronized开始位置(Monitor Enter)有相同的语义,即使用共享变量时会从主内存中刷新变量值到工作内存中(即从主内存中读取最新值到线程私有的工作内存中),在方法的最后finally块里执行lock.unlock()方法,和synchronized结束位置(Monitor Exit)有相同的语义,即会将工作内存中的变量值同步到主内存中去(即将线程私有的工作内存中的值写入到主内存进行同步)。
final关键字的可见性是指:被final修饰的变量,在构造函数数一旦初始化完成,并且在构造函数中并没有把“this”的引用传递出去(“this”引用逃逸是很危险的,其他的线程很可能通过该引用访问到只“初始化一半”的对象),那么其他线程就可以看到final变量的值。
有序性:对于一个线程的代码而言,我们总是以为代码的执行是从前往后的,依次执行的。这么说不能说完全不对,在单线程程序里,确实会这样执行;但是在多线程并发时,程序的执行就有可能出现乱序。用一句话可以总结为:在本线程内观察,操作都是有序的;如果在一个线程中观察另外一个线程,所有的操作都是无序的。前半句是指“线程内表现为串行语义(WithIn Thread As-if-Serial Semantics)”,后半句是指“指令重排”现象和“工作内存和主内存同步延迟”现象。
Java提供了两个关键字volatile和synchronized来保证多线程之间操作的有序性,volatile关键字本身通过加入内存屏障来禁止指令的重排序,而synchronized关键字通过一个变量在同一时间只允许有一个线程对其进行加锁的规则来实现,
在单线程程序中,不会发生“指令重排”和“工作内存和主内存同步延迟”现象,只在多线程程序中出现。
happens-before原则:
Java内存模型中定义的两项操作之间的次序关系,如果说操作A先行发生于操作B,操作A产生的影响能被操作B观察到,“影响”包含了修改了内存中共享变量的值、发送了消息、调用了方法等。
下面是Java内存模型下一些”天然的“happens-before关系,这些happens-before关系无须任何同步器协助就已经存在,可以在编码中直接使用。如果两个操作之间的关系不在此列,并且无法从下列规则推导出来的话,它们就没有顺序性保障,虚拟机可以对它们进行随意地重排序。
a.程序次序规则(Pragram Order Rule):在一个线程内,按照程序代码顺序,书写在前面的操作先行发生于书写在后面的操作。准确地说应该是控制流顺序而不是程序代码顺序,因为要考虑分支、循环结构。
b.管程锁定规则(Monitor Lock Rule):一个unlock操作先行发生于后面对同一个锁的lock操作。这里必须强调的是同一个锁,而”后面“是指时间上的先后顺序。
c.volatile变量规则(Volatile Variable Rule):对一个volatile变量的写操作先行发生于后面对这个变量的读取操作,这里的”后面“同样指时间上的先后顺序。
d.线程启动规则(Thread Start Rule):Thread对象的start()方法先行发生于此线程的每一个动作。
e.线程终于规则(Thread Termination Rule):线程中的所有操作都先行发生于对此线程的终止检测,我们可以通过Thread.join()方法结束,Thread.isAlive()的返回值等作段检测到线程已经终止执行。
f.线程中断规则(Thread Interruption Rule):对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生,可以通过Thread.interrupted()方法检测是否有中断发生。
g.对象终结规则(Finalizer Rule):一个对象初始化完成(构造方法执行完成)先行发生于它的finalize()方法的开始。
g.传递性(Transitivity):如果操作A先行发生于操作B,操作B先行发生于操作C,那就可以得出操作A先行发生于操作C的结论。
一个操作”时间上的先发生“不代表这个操作会是”先行发生“,那如果一个操作”先行发生“是否就能推导出这个操作必定是”时间上的先发生 “呢?也是不成立的,一个典型的例子就是指令重排序。所以时间上的先后顺序与happens-before原则之间基本没有什么关系,所以衡量并发安全问题一切必须以happens-before 原则为准。
多线程与Java的JMM内存模型的更多相关文章
- JMM内存模型详解(一)
本文开始死磕JMM(Java内存模型)由于知识点较多,分来写 该文为JMM第一篇 技术往往是枯燥的,本文文字较多 1. JMM是什么? 其实JMM很好理解,我简单的解释一下,在Java多线程中我们经常 ...
- Java并发之内存模型(JMM)浅析
背景 学习Java并发编程,JMM是绕不过的槛.在Java规范里面指出了JMM是一个比较开拓性的尝试,是一种试图定义一个一致的.跨平台的内存模型.JMM的最初目的,就是为了能够支多线程程序设计的,每个 ...
- JMM内存模型相关笔记整理
JMM 内存模型是围绕并发编程中原子性.可见性.有序性三个特征来建立的 原子性:就是说一个操作不能被打断,要么执行完要么不执行,类似事务操作,Java 基本类型数据的访问大都是原子操作,long 和 ...
- 关于JAVA中的static方法、并发问题以及JAVA运行时内存模型
一.前言 最近在工作上用到了一个静态方法,跟同事交流的时候,被一个问题给问倒了,只怪基础不扎实... 问题大致是这样的,“在多线程环境下,静态方法中的局部变量会不会被其它线程给污染掉?”: 我当时的想 ...
- Java虚拟机:内存模型详解
版权声明:本文为博主原创文章,转载请注明出处,欢迎交流学习! 我们都知道,当虚拟机执行Java代码的时候,首先要把字节码文件加载到内存,那么这些类的信息都存放在内存中的哪个区域呢?当我们创建一个对象实 ...
- JVM学习(七)JMM内存模型
一.什么是JMM 概念:Java内存模型(Java Memory Model ,JMM)就是一种符合内存模型规范的,屏蔽了各种硬件和操作系统的访问差异的,保证了Java程序在各种平台下对内存的访问都能 ...
- Java对象的内存模型(一)
前言 新人一枚,刚刚入门编程不久,各方面都在学习当中,博文有什么错误的地方,希望我们可以多多交流! 最近,在开发App后台过程中,需要将项目部署到云服务器上.而云服务器的内存大小却只有1G.要如何做到 ...
- java虚拟机的内存模型
一.为什么要了解java虚拟机的内存模型 java虚拟机作为java代码运行的平台,是java技术的基石.了解java虚拟机的内存模型也就变得十分必要.它能帮助我们更好的了解java代码的运行机制,更 ...
- JAVA并发编程的艺术 JMM内存模型
锁的升级和对比 java1.6为了减少获得锁和释放锁带来的性能消耗,引入了"偏向锁"和"轻量级锁". 偏向锁 偏向锁为了解决大部分情况下只有一个线程持有锁的情况 ...
随机推荐
- Solidworks拖动装配体的时候物资动力有什么用
Solidworks物资动力就是模拟真实的场景,你在拖动或旋转零件的时候会和周围的零件碰撞,有相互力的作用. 1 标准拖动 2 碰撞检查 3 选择物资动力(零件上面的黑白相间小圆表示物体重心) ...
- 读刘未鹏老大《你应当怎样学习C++(以及编程)》
标签(空格分隔): 三省吾身 原文地址:你应当怎样学习C++(以及编程) 本人反思自己这些年在学校学得稀里糊涂半灌水. 看到这篇文章,感觉收获不少.仿佛有指明自己道路的感觉,当然真正困难的还是坚持学习 ...
- MySQL具体解释(14)----------事务处理
前言:前一篇文章关于事务处理的博文没有写清楚,读起来非常晦涩.非常难理解,所以有整理了一些资料,帮助理解.见谅! 关于MySQL事务处理学习记 START TRANSACTION COMMIT ROL ...
- storm笔记:Storm+Kafka简单应用
storm笔记:Storm+Kafka简单应用 这几天工作须要使用storm+kafka,基本场景是应用出现错误,发送日志到kafka的某个topic.storm订阅该topic.然后进行兴许处理.场 ...
- 面试题 15:链表中倒数第 k 个结点
面试题 15:链表中倒数第 k 个结点 题目:输入一个链表,输出该链表中倒数第 k 个结点.为了符合大多数人的习惯, 本题从 1 开始计数,即链表的尾结点是倒数第一个结点.例如一个有 6 个结点的 链 ...
- MySQL 优化、设计规则浅谈
当数据量大,数据库相应慢时都会针对数据库进行优化.这时都是要针对具体情况,具体业务需求进行优化的. 但是有些步骤和规则应该适合各种情况的.这里综合网上找的资料简单分析一下. 第一优化你的sql和索引: ...
- Java编码辅助工具:Lombok —— 避免重复臃肿的代码,提高效率
在项目开发过程中,经常会涉及到一些调整很少但又必不可少的环节,比如实体类的Getter/Setter方法,ToString方法等.这时可以使用Lombok来避免这种重复的操作,减少非核心代码的臃肿,提 ...
- SpringBoot启动流程分析(一):SpringApplication类初始化过程
SpringBoot系列文章简介 SpringBoot源码阅读辅助篇: Spring IoC容器与应用上下文的设计与实现 SpringBoot启动流程源码分析: SpringBoot启动流程分析(一) ...
- mysql日期格式转化
select DATE_FORMAT( '20170701', '%Y-%m-%d'); 先挖坑
- 32.10 使用模板更改控件的UI
32.10 使用模板更改控件的UI 样式是改变WPF控件基本外形的非常好(且非常简单)的方式,它通过为窗口部件的特性设置建立一组默认的值,从而改变WPF控件的基本外形.但是,即使样式允许我们改变各种 ...