BT

深入理解Java内存模型(一)——基础

作者 程晓明 发布于 2013年1月22日 | 被首富的“一个亿”刷屏?不如定个小目标,先把握住QCon上海的优惠吧!

并发编程模型的分类

在并发编程中,我们需要处理两个关键问题:线程之间如何通信及线程之间如何同步(这里的线程是指并发执行的活动实体)。通信是指线程之间以何种机制来交换信息。在命令式编程中,线程之间的通信机制有两种:共享内存和消息传递。

在共享内存的并发模型里,线程之间共享程序的公共状态,线程之间通过写-读内存中的公共状态来隐式进行通信。在消息传递的并发模型里,线程之间没有公共状态,线程之间必须通过明确的发送消息来显式进行通信。

同步是指程序用于控制不同线程之间操作发生相对顺序的机制。在共享内存并发模型里,同步是显式进行的。程序员必须显式指定某个方法或某段代码需要在线程之间互斥执行。在消息传递的并发模型里,由于消息的发送必须在消息的接收之前,因此同步是隐式进行的。

Java的并发采用的是共享内存模型,Java线程之间的通信总是隐式进行,整个通信过程对程序员完全透明。如果编写多线程程序的Java程序员不理解隐式进行的线程之间通信的工作机制,很可能会遇到各种奇怪的内存可见性问题。

Java内存模型的抽象

在java中,所有实例域、静态域和数组元素存储在堆内存中,堆内存在线程之间共享(本文使用“共享变量”这个术语代指实例域,静态域和数组元素)。局部变量(Local variables),方法定义参数(java语言规范称之为formal method parameters)和异常处理器参数(exception handler parameters)不会在线程之间共享,它们不会有内存可见性问题,也不受内存模型的影响。

Java线程之间的通信由Java内存模型(本文简称为JMM)控制,JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看,JMM定义了线程和主内存之间的抽象关系:线程之间的共享变量存储在主内存(main memory)中,每个线程都有一个私有的本地内存(local memory),本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念,并不真实存在。它涵盖了缓存,写缓冲区,寄存器以及其他的硬件和编译器优化。Java内存模型的抽象示意图如下:

从上图来看,线程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程序员提供内存可见性保证。

重排序

在执行程序时为了提高性能,编译器和处理器常常会对指令做重排序。重排序分三种类型:

  1. 编译器优化的重排序。编译器在不改变单线程程序语义的前提下,可以重新安排语句的执行顺序。
  2. 指令级并行的重排序。现代处理器采用了指令级并行技术(Instruction-Level Parallelism, ILP)来将多条指令重叠执行。如果不存在数据依赖性,处理器可以改变语句对应机器指令的执行顺序。
  3. 内存系统的重排序。由于处理器使用缓存和读/写缓冲区,这使得加载和存储操作看上去可能是在乱序执行。

从java源代码到最终实际执行的指令序列,会分别经历下面三种重排序:

上述的1属于编译器重排序,2和3属于处理器重排序。这些重排序都可能会导致多线程程序出现内存可见性问题。对于编译器,JMM的编译器重排序规则会禁止特定类型的编译器重排序(不是所有的编译器重排序都要禁止)。对于处理器重排序,JMM的处理器重排序规则会要求java编译器在生成指令序列时,插入特定类型的内存屏障(memory barriers,intel称之为memory fence)指令,通过内存屏障指令来禁止特定类型的处理器重排序(不是所有的处理器重排序都要禁止)。

JMM属于语言级的内存模型,它确保在不同的编译器和不同的处理器平台之上,通过禁止特定类型的编译器重排序和处理器重排序,为程序员提供一致的内存可见性保证。

处理器重排序与内存屏障指令

现代的处理器使用写缓冲区来临时保存向内存写入的数据。写缓冲区可以保证指令流水线持续运行,它可以避免由于处理器停顿下来等待向内存写入数据而产生的延迟。同时,通过以批处理的方式刷新写缓冲区,以及合并写缓冲区中对同一内存地址的多次写,可以减少对内存总线的占用。虽然写缓冲区有这么多好处,但每个处理器上的写缓冲区,仅仅对它所在的处理器可见。这个特性会对内存操作的执行顺序产生重要的影响:处理器对内存的读/写操作的执行顺序,不一定与内存实际发生的读/写操作顺序一致!为了具体说明,请看下面示例:

Processor A Processor B
a = 1; //A1
x = b; //A2
b = 2; //B1
y = a; //B2
初始状态:a = b = 0
处理器允许执行后得到结果:x = y = 0

假设处理器A和处理器B按程序的顺序并行执行内存访问,最终却可能得到x = y = 0的结果。具体的原因如下图所示:

这里处理器A和处理器B可以同时把共享变量写入自己的写缓冲区(A1,B1),然后从内存中读取另一个共享变量(A2,B2),最后才把自己写缓存区中保存的脏数据刷新到内存中(A3,B3)。当以这种时序执行时,程序就可以得到x = y = 0的结果。

从内存操作实际发生的顺序来看,直到处理器A执行A3来刷新自己的写缓存区,写操作A1才算真正执行了。虽然处理器A执行内存操作的顺序为:A1->A2,但内存操作实际发生的顺序却是:A2->A1。此时,处理器A的内存操作顺序被重排序了(处理器B的情况和处理器A一样,这里就不赘述了)。

这里的关键是,由于写缓冲区仅对自己的处理器可见,它会导致处理器执行内存操作的顺序可能会与内存实际的操作执行顺序不一致。由于现代的处理器都会使用写缓冲区,因此现代的处理器都会允许对写-读操做重排序。

下面是常见处理器允许的重排序类型的列表:

  Load-Load Load-Store Store-Store Store-Load 数据依赖
sparc-TSO N N N Y N
x86 N N N Y N
ia64 Y Y Y Y N
PowerPC Y Y Y Y N

上表单元格中的“N”表示处理器不允许两个操作重排序,“Y”表示允许重排序。

从上表我们可以看出:常见的处理器都允许Store-Load重排序;常见的处理器都不允许对存在数据依赖的操作做重排序。sparc-TSO和x86拥有相对较强的处理器内存模型,它们仅允许对写-读操作做重排序(因为它们都使用了写缓冲区)。

※注1:sparc-TSO是指以TSO(Total Store Order)内存模型运行时,sparc处理器的特性。

※注2:上表中的x86包括x64及AMD64。

※注3:由于ARM处理器的内存模型与PowerPC处理器的内存模型非常类似,本文将忽略它。

※注4:数据依赖性后文会专门说明。

为了保证内存可见性,java编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序。JMM把内存屏障指令分为下列四类:

屏障类型 指令示例 说明
LoadLoad Barriers Load1; LoadLoad; Load2 确保Load1数据的装载,之前于Load2及所有后续装载指令的装载。
StoreStore Barriers Store1; StoreStore; Store2 确保Store1数据对其他处理器可见(刷新到内存),之前于Store2及所有后续存储指令的存储。
LoadStore Barriers Load1; LoadStore; Store2 确保Load1数据装载,之前于Store2及所有后续的存储指令刷新到内存。
StoreLoad Barriers Store1; StoreLoad; Load2 确保Store1数据对其他处理器变得可见(指刷新到内存),之前于Load2及所有后续装载指令的装载。StoreLoad Barriers会使该屏障之前的所有内存访问指令(存储和装载指令)完成之后,才执行该屏障之后的内存访问指令。

StoreLoad Barriers是一个“全能型”的屏障,它同时具有其他三个屏障的效果。现代的多处理器大都支持该屏障(其他类型的屏障不一定被所有处理器支持)。执行该屏障开销会很昂贵,因为当前处理器通常要把写缓冲区中的数据全部刷新到内存中(buffer fully flush)。

happens-before

从JDK5开始,java使用新的JSR -133内存模型(本文除非特别说明,针对的都是JSR- 133内存模型)。JSR-133提出了happens-before的概念,通过这个概念来阐述操作之间的内存可见性。如果一个操作执行的结果需要对另一个操作可见,那么这两个操作之间必须存在happens-before关系。这里提到的两个操作既可以是在一个线程之内,也可以是在不同线程之间。 与程序员密切相关的happens-before规则如下:

  • 程序顺序规则:一个线程中的每个操作,happens- before 于该线程中的任意后续操作。
  • 监视器锁规则:对一个监视器锁的解锁,happens- before 于随后对这个监视器锁的加锁。
  • volatile变量规则:对一个volatile域的写,happens- before 于任意后续对这个volatile域的读。
  • 传递性:如果A happens- before B,且B happens- before C,那么A happens- before C。

注意,两个操作之间具有happens-before关系,并不意味着前一个操作必须要在后一个操作之前执行!happens-before仅仅要求前一个操作(执行的结果)对后一个操作可见,且前一个操作按顺序排在第二个操作之前(the first is visible to and ordered before the second)。happens- before的定义很微妙,后文会具体说明happens-before为什么要这么定义。

happens-before与JMM的关系如下图所示:

如上图所示,一个happens-before规则通常对应于多个编译器重排序规则和处理器重排序规则。对于java程序员来说,happens-before规则简单易懂,它避免程序员为了理解JMM提供的内存可见性保证而去学习复杂的重排序规则以及这些规则的具体实现。

参考文献

  1. Programming Language Pragmatics, Third Edition
  2. The Java Language Specification, Third Edition
  3. JSR-133: Java Memory Model and Thread Specification
  4. Java theory and practice: Fixing the Java Memory Model, Part 2
  5. Understanding POWER Multiprocessors
  6. Concurrent Programming on Windows
  7. The Art of Multiprocessor Programming
  8. Intel® 64 and IA-32 ArchitecturesvSoftware Developer’s Manual Volume 3A: System Programming Guide, Part 1
  9. Java Concurrency in Practice
  10. The JSR-133 Cookbook for Compiler Writers

关于作者

程晓明,Java软件工程师,国家认证的系统分析师、信息项目管理师。专注于并发编程,就职于富士通南大。个人邮箱:asst2003@163.com


感谢张龙对本文的审校。

给InfoQ中文站投稿或者参与内容翻译工作,请邮件至editors@cn.infoq.com。也欢迎大家通过新浪微博(@InfoQ)或者腾讯微博(@InfoQ)关注我们,并与我们的编辑和其他读者朋友交流。

评价本文

专业度
风格

您好,朋友!

您需要 注册一个InfoQ账号 或者 才能进行评论。在您完成注册后还需要进行一些设置。

获得来自InfoQ的更多体验。

告诉我们您的想法

允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p

当有人回复此评论时请E-mail通知我
社区评论

几个不解的地方 by 丁 佳砙

在线程A和B的那个例子中:
A更新了本地副本x的值,不会主动刷新到主存中吗,必须等到和B通信时?另外,为什么是A和B通信,而不是B和A通信?这个时候A已经执行完了操作呀。

是指令级还是指令集?

Re: 几个不解的地方 by 傅 晗

个人理解A和B线程的例子是为了说明JVM内部模拟cpu的内存模型,它自己重新实现了一遍.比如如果A线程更新的x是一个volatile修饰的,那么就会模拟cache一致性,将本地副本的x的最新值刷新到主存来让B使用.这也就符合了happens-before

Re: 几个不解的地方 by 程 晓明

A更新了本地副本x的值,不会主动刷新到主存中吗,必须等到和B通信时?
--A线程迟早会把更新过的X值刷新到主内存中,但具体会在什么时候刷新到主内存是不确定的。如果我们使用同步原语(synchronized,volatile和final),那么刷新的时机是确定的。比如,如果A线程释放了锁,它就会刷新本地内存A;接下来如果B线程获取同一个锁,B线程就会到主内存中去读取共享变量的值。此时,B线程就可以读取到A线程对共享变量所做的修改了(即“A线程释放锁--B线程获取锁”可以实现A,B线程之间的通信)。

另外,为什么是A和B通信,而不是B和A通信?
--这里的通信是指线程之间通过共享变量来沟通。由于共享变量在所有线程之间共享,如果A,B线程之间需要沟通,只需要A线程把写过的共享变量的值刷新到主内存,随后B线程到到主内存中去读取这些共享变量即可。这个过程可以让B线程看到A线程对共享变量锁做的修改,这种线程之间的沟通方式在本文中称之为通信。

Re: 几个不解的地方 by 程 晓明

是指令级还是指令集?
--是指令级。
指令级并行(Instruction-Level Parallelism, ILP)是指处理器将多条指令重叠执行以提高性能,这种重叠称之为指令级并行。
一个处理器支持的指令和指令的字节级编码称之为指令集体系结构(Instruction Set Architecture, ISA)

Re: 几个不解的地方 by 程 晓明

不好意思,最后一句话打错了一个字。“锁”应该改为“所”。
即:这个过程可以让B线程看到A线程对共享变量所做的修改,这种线程之间的沟通方式在本文中称之为通信。

Re: 几个不解的地方 by 丁 佳砙

thanks。
我忘了本文的大前提,理解成A和B的通信有主动方和被动方了。

关于配图 by Chen reniaL

配图还敢再丑一些么~

Re: 关于配图 by Shui Arthur

抱歉,我们稍后就对配图做修改,谢谢

一个描述问题 by Dong Pengfei

共享内存并发模型里,同步是显式进行的。程序员必须显式指定某个方法或某段代码需要在线程之间互斥执行。在消息传递的并发模型里,由于消息的发送必须在消息的接收之前,因此同步是隐式进行的。
Java的并发采用的是共享内存模型,Java线程之间的通信总是隐式进行,整个通信过程对程序员完全透明。

这表述为什么前后不一致?

Re: 一个描述问题 by 程 晓明

您好,原文简单概括如下:
并发编程要处理两个关键问题:通信和同步。
共享内存模型:显式同步,隐式通信。
消息传递模型:显式通信,隐式同步。
由于java的并发采用共享内存模型,所以java线程之间的通信是隐式进行的。

结合聊聊并发系列文章,好好补补知识结构,感谢作者的分享 by rao aaron

结合聊聊并发系列文章,好好补补知识结构,感谢作者的分享

Re: 一个描述问题 by Guo Gem

很好, 令人记性深刻! 多谢!

Re: 关于配图 by Neo Tan

能多尊重作者/译者么?

谢谢分享 by tian jason

感谢作者的分享,使我对JMM有了更深入的认识,不过有很多地方还是不太明白,先继续还着问题往下看其他几个部分,感谢

并发语言erlang相比 by zehe chen

erlang这种并发语言就是采用消息传递的方式来通信的,其内部最一切都是线程就像java的一切都是对象一样,它的变量一经定义赋值就不可改变,不存在锁这种东西,为并发而存在

楼主,我一直有个问题:请教,希望不吝赐教 by 增发 li

既然现代处理器,都会有mesi协议保证数据一致性,为何在你举的第一个例子里,会存在数据可见性问题呢,突然想到~

Re: 楼主,我一直有个问题:请教,希望不吝赐教 by 程 晓明

mesi协议保证缓存一致性而非数据一致性。
《Computer Architecture: A Quantitative Approach, 4th Edition》的4.2章,对缓存一致性有详细的说明。

我举的第一个例子(关于写缓冲区),来自于参考文献8的8.2.3.5。在这一章节的最后,有下面这段话:
In practice, the reordering in this example can arise as a result of store-buffer forwarding. While a store is temporarily held in a processor's store buffer, it can satisfy the processor's own loads but is not visible to (and cannot satisfy) loads by other processors.
上面这段话的大意是说:
事实上,这个例子能够出现这样的结果,是因为store-buffer forwarding。当一个写操作被临时保存在一个处理器的写缓存区时,这个写操作能被该处理器自己读取到;但这个写操作对其他处理器不可见,也不能被其他处理器读取到。

不错 by wuya wuya

写的挺好的,更加理解了,但是请问 java 的内存模型是 根据反编译jvm 来 分析的还是 看来某些书,源头在哪里
简单的说是 说是 java线程通信 是隐式的 是怎么分析过来的

关于在线程之间共享的元素 by 黄 春

有个问提请教下。

文中提到“实例域、静态域和数组元素存储在堆内存中,堆内存在线程之间共享”。 那如果是方法里面定义的一个局部数组,也是线程间共享的么?

Re: 不错 by 程 晓明

如果对java内存模型感兴趣的话,可以从下面三个文献入手:
JSR-133: Java Memory Model and Thread Specification
The JSR-133 Cookbook for Compiler Writers
JSR 133 (Java Memory Model) FAQ

Java的并发采用的是共享内存模型,共享内存模型的线程间通信是隐式进行的。
如果对于这个主题感兴趣的话,可以参阅Michael L. Scott的《Programming Language Pragmatics, Third Edition 》的第12章。

Re: 关于在线程之间共享的元素 by 程 晓明

如果这个数组始终对其他线程不可见,那它虽然存储在堆内存中,但任然是该线程独有的。

Re: 关于在线程之间共享的元素 by he haibo

这几天看了些资料,我是这么理解的,在某个方法里面定义了一个数组,这个数组的对其他线程是不可见的,因为每个线程都有自己的独立内存空间,称之为Java方法栈,其生命周期和线程的生命周期一致,至于这个数组存放在哪里,可能是存放当前线程的PC寄存器里,PC寄存器可以利用java的堆内存也可以直接就存放在该PC寄存器的内存空间内。如果是存放在java 的堆内存中,对其他现场是可见的,但是没有线程去使用它,即就是本文所说没有通信,因此还是线程安全的。如果是直接 存放在寄存器内,效率很高。我想这就是线程栈封闭的一部分吧~

Re: 关于在线程之间共享的元素 by he haibo

如果有理解错误的地方,还请多指正,这块实战实确实是不多

在java中,静态变量保存在堆还是栈里面? by 刘 杰

看作者文章中说”在java中,所有实例域、静态域和数组元素存储在堆内存中“ 但,网上很多说法却与此不同,比如:bbs.csdn.net/topics/370001490 。关于这个问题有明确答案吗?

部分建议和探讨 by 孟 衡

先坦白说一句(不带任何不好的意思),这篇文章对于没有内存模型基础的来说,太难了,很难理解,比如重排序的概念介绍地较粗、内存屏障的概念不好懂、以及如果没有JMM基础那介绍处理器支持重排序类型过早,大多java程序员对硬件及汇编是不太懂的;而对于有内存模型基础的来说,又似乎有些大而全、不够深入。建议文章应该有”读者对象"部分才好,指明阅读者应具备的基础。
好了,建议就提到这里,讨论个问题。
文章开头提到“本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念,并不真实存在。它涵盖了缓存,写缓冲区,寄存器以及其他的硬件和编译器优化”,针对这里本地内存是不真实存在,我有些疑问。虚拟机会为每个线程开辟一块虚拟机栈,默认大小1M,这是实实在在占用java进程内存的,这不就是每个线程专属的本地内存吗?它应该是实实在在存在的。缓存、写缓冲区的概念比较模糊,不清楚是CPU的还是内存的,不讨论,但寄存器和Java的内存模型是两个概念,是属于CPU级别的缓存,已经不是虚拟机所能控制的范围,任何内存发起的访问都会使用到寄存器,而不限于线程,我觉得不应该把它划为线程的本地内存。

Re: 在java中,静态变量保存在堆还是栈里面? by 程 晓明

在java中,所有实例域、静态域和数组元素存储在堆内存中
--这句话是《The Java™ Language Specification Java SE 7 Edition》的17.4.1的原文(※1):
Memory that can be shared between threads is called shared memory or heap
memory.
All instance fields, static fields, and array elements are stored in heap memory.
上面这段话的大意是说:
内存能在线程之间共享,它被称为共享内存或堆内存。
所有实例域、静态域和数组元素存储在堆内存中。

从上面这段话来看,这里的堆内存指的是在线程之间共享的内存区域。
______________________________________

我们再来看《The Java™ Virtual Machine Specification Java SE 7 Edition》的描述。
在2.5.3中有如下说明(※2):
The Java virtual machine has a heap that is shared among all Java virtual machine
threads. The heap is the runtime data area from which memory for all class
instances and arrays is allocated.
上面这段话的大意是说:
java虚拟机有一个堆内存,它在所有java虚拟机线程之间共享。堆是存放运行时数据的内存区域,所有类的实例和数组都在堆上分配。

2.5.4章的第一段话(※3):
The Java virtual machine has a method area that is shared among all Java virtual
machine threads... It stores per-class structures such as the runtime constant pool, field and method data, and the code for methods and constructors...
上面这段话的大意是说:
java虚拟机有一个在所有线程之间共享的方法区。。。它存储每一个类的结构信息,比如运行时常量池,域和方法数据,以及方法和构造函数的字节码。。。

2.5.4章的第二段话(※4):
The method area is created on virtual machine start-up. Although the method area is logically part of the heap, simple implementations may choose not to either garbage collect or compact it.
这段话的大意是说:
方法区在虚拟机启动的时候创建。尽管方法区是堆的逻辑部分,但简单的jvm实现可以选择不对其进行垃圾收集或压缩。

**************************************

这里把※2中描述的堆,称之为“java堆”。
在※4中指出,方法区隶属于堆的逻辑部分,这里把这个包含了方法区的堆称之为“广义上的堆”。
由于java堆和方法区在所有java虚拟机线程之间共享,
所以※1中所说的“在线程之间共享的共享内存或堆内存”,指的是“广义上的堆”而非“java堆”。

Re: 部分建议和探讨 by 程 晓明

建议文章应该有”读者对象"部分才好,指明阅读者应具备的基础。
--这个建议很好,谢谢。

在涉及JSR-133的几个规范中,都不存在本地内存的概念:
《JSR-133: Java Memory Model and Thread Specification》,
《The Java™ Language Specification Third Edition》
《The Java™ Language Specification Java SE 7 Edition》,
《The Java™ Virtual Machine Specification Java SE 7 Edition》

本地内存以及这段话的描述,是从Brian Goetz写的一篇关于JSR-133内存模型的非常著名的文章中借鉴而来:
《Java theory and practice: Fixing the Java Memory Model, Part 2》
URL:www.ibm.com/developerworks/library/j-jtp03304/i...

Brian Goetz通过使用本地内存这个概念来抽象CPU,内存系统和编译器的优化。

很详尽但是感觉不够透彻 by 扬 清风

博主很有研究哈,这个系列列举了很多内容,但是感觉有点没有完全嚼烂融会贯通的感觉。就像是一碗看起来已经很烂的粥,但是嚼着嚼着就崩到了一颗桃仁。还是没有国外大牛的博客解析得清晰透彻

Re: 一个描述问题 by 王 伟

请仔细在好好阅读下

多线程会导致占用重复的内存空间吗? by lao li

如果一个变量在主内存和工作内存中都存在,那是不是会导致对于“少量”对象,他们会占用好几份内存空间。具体多少份取决于并发线程数量?

Re: 一个描述问题 by liang xuewen

很好的解释,谢谢,
有个问题,这里提到的 消息传递模型,在java中有什么实现或应用么,或者在其他平台或系统的,有应用的小例子么,谢谢

Re: 多线程会导致占用重复的内存空间吗? by liang xuewen

有同样的疑问,所以并发线程多了了,就会导致内存占用严重,性能下降,期待大牛回复

谢谢

如果作者能讲解下缓存就更好了 by King Henry

文章写得很好。不过值得一提的是:现在的CPU都有多级缓存,一级缓存是和核关联的,二级或者三级缓存是多核共享的。如果线程1对数据做了修改,有可能只是反应到L3缓存,线程2直接从L3缓存取数据。具体的可以看下MESI协议,缓存是writeback还是writethrough。

Re: 多线程会导致占用重复的内存空间吗? by 黄 文海

内存占用主要有3个方面:1)一个线程就是一个对象,对象本身会占用内存空间;2)创建线程(即Thread实例)的时候,JVM会未每个这样的对象(对象本身占用内存)额外分配两个线程调用栈(callstack)所需的内存空间,一个用于跟踪Java方法调用,另一个用于跟踪本地(native)方法调用);3)线程运行过程中可能持有对其它对象的引用,只要这些线程没有终止,那么这些 被引用的对象就无法被垃圾回收。
性能下降,要具体问题具体分析,但是从一般的角度看,可以从上下文切换的角度去分析:一般地,线程数量越多,产生上下文切换就越多,其处理器时间开销也越大。这也就意味着,处理器用于执行应用代码的时间也相对减少。这呈现出来的效果就是应用性能下降。在Java8中可以使用JMC监控下Java应用的上下文切换数量(单位监控时间内的)。

Re: 多线程会导致占用重复的内存空间吗? by 黄 文海

回答这个问题首先要弄清究竟什么是工作内存,什么是主内存(指RAM?指Java Heap内存?)。所以,我觉得还是不要去纠结什么是工作内存、什么是主内存。那只是JVM规范为了叙述方便弄出的术语(可能是考虑跨平台吧,我想)。其实,我们只需要弄清楚一点:处理器并不是直接访问RAM(事实上,它也称主内存),而是通过高速缓存(Cache)访问内存。也就是说,从高级语言代码的角度看的一个变量,我们可以理解为它是存在RAM中的。因此对变量的读写操作就是对RAM的读写操作。但是,处理器对我们所谓的读写内存操作实际上是对高速缓存的读写操作。以一个单处理器的系统为例,代码中的一个变量其实是同时占用一份RAM空间和一份高速缓存空间。那么,对于多核处理器的系统而言,这一个变量还是占用一份RAM空间,所不同的是它可能同时占用多份高速缓存空间。而缓存相关性(Cache Coherence)协议则是用来保证高速缓存之间以及高速缓存与RAM之间的数据的一致性。

Re: 关于在线程之间共享的元素 by 黄 文海

对象能否被多个线程共享和它存在哪里没有必然联系。这其实是要分清楚对象与对象的引用的差别。“实例域、静态域和数组元素存储在堆内存中,堆内存在线程之间共享”这句话干脆理解成对象是存储在堆内存中的比较简单。而对象的引用可以理解成一个值,这个值就像是int、char这样的值一样,可以存储在Stack空间中,只不过对象的引用这个值是一个内存地址,而不是像int型的123或者char型的'V'。因此,如果是在方法体内调用的一个局部数组如:
void methodA(){
Object[] objects=new Object[]{new Object(),new Object(),new Object()};
}
显然,objects数组引用的3个对象是存在堆内存中的,而objects数组引用本身是存储在stack空间中的。但是,由于一个线程不能直接访问另外一个线程的stack空间,因此上述的数组事实上是无法在多个线程之间共享的。

允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p

当有人回复此评论时请E-mail通知我

允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p

当有人回复此评论时请E-mail通知我

36 讨论
提供反馈
错误报告
商务合作
内容合作
Marketing
InfoQ.com及所有内容,版权所有 © 2006-2016 C4Media Inc. InfoQ.com 服务器由 Contegix提供, 我们最信赖的ISP伙伴。
北京创新网媒广告有限公司 京ICP备09022563号-7 隐私政策
BT

We notice you’re using an ad blocker

We understand why you use ad blockers. However to keep InfoQ free we need your support. InfoQ will not provide your data to third parties without individual opt-in consent. We only work with advertisers relevant to our readers. Please consider whitelisting us.