- 浏览: 579679 次
- 性别:
- 来自: 成都
文章分类
最新评论
-
a1641693970:
还不错,学习了
BeanUtils使用总结(二)LazyDynaBean -
zjfshowtime:
很好的办法,学习了。
ORA-28001: the password has expired -
ya654277yo:
哦,多谢分享
Apache整合Tomcat后get方式提交中文乱码问题解决 -
foolkeeper:
nice !!
jvm内存参数设定 -
tracy821:
谢谢了,找了好久才找到
关于Spring 声明式事务处理时,throws exception不回滚的问题
在了解Java的同步秘密之前,先来看看JMM(Java Memory Model)。
Java被设计为跨平台的语言,在内存管理上,显然也要有一个统一的模型。而且Java语言最大的特点就是废除了指针,把程序员从痛苦中解脱出来,不用再考虑内存使用和管理方面的问题。
可惜世事总不尽如人意,虽然JMM设计上方便了程序员,但是它增加了虚拟机的复杂程度,而且还导致某些编程
技巧在Java语言中失效。
JMM 主要是为了规定了线程和内存之间的一些关系。对Java程序员来说只需负责用synchronized同步关键字,其它诸如与线程/内存之间进行数据交换 /同步等繁琐工作均由虚拟机负责完成。如图1所示:根据JMM的设计,系统存在一个主内存(Main Memory),Java中所有变量都储存在主存中,对于所有线程都是共享的。每条线程都有自己的工作内存(Working Memory),工作内存中保存的是主存中某些变量的拷贝,线程对所有变量的操作都是在工作内存中进行,线程之间无法相互直接访问,变量传递均需要通过主 存完成。
图1 Java内存模型示例图
线 程若要对某变量进行操作,必须经过一系列步骤:首先从主存复制/刷新数据到工作内存,然后执行代码,进行引用/赋值操作,最后把变量内容写回Main Memory。Java语言规范(JLS)中对线程和主存互操作定义了6个行为,分别为load,save,read,write,assign和 use,这些操作行为具有原子性,且相互依赖,有明确的调用先后顺序。具体的描述请参见JLS第17章。
我们在前面的章节介绍了synchronized的作用,现在,从JMM的角度来重新审视synchronized关键字。
假设某条线程执行一个synchronized代码段,其间对某变量进行操作,JVM会依次执行如下动作:
(1) 获取同步对象monitor (lock)
(2) 从主存复制变量到当前工作内存 (read and load)
(3) 执行代码,改变共享变量值 (use and assign)
(4) 用工作内存数据刷新主存相关内容 (store and write)
(5) 释放同步对象锁 (unlock)
可 见,synchronized的另外一个作用是保证主存内容和线程的工作内存中的数据的一致性。如果没有使用synchronized关键字,JVM不保 证第2步和第4步会严格按照上述次序立即执行。因为根据JLS中的规定,线程的工作内存和主存之间的数据交换是松耦合的,什么时候需要刷新工作内存或者更 新主内存内容,可以由具体的虚拟机实现自行决定。如果多个线程同时执行一段未经synchronized保护的代码段,很有可能某条线程已经改动了变量的 值,但是其他线程却无法看到这个改动,依然在旧的变量值上进行运算,最终导致不可预料的运算结果。
二、DCL失效
这一节我们要讨论的是一个让Java丢脸的话题:DCL失效。在开始讨论之前,先介绍一下LazyLoad,这种技巧很常用,就是指一个类包含某个成员变量,在类初始化的时候并不立即为该变量初始化一个实例,而是等到真正要使用到该变量的时候才初始化之。
例如下面的代码:
代码1
class
Foo {
private
Resource res = null
;
public
Resource getResource() {
if
(res == null
)
res = new
Resource();
return
res;
}
}
由于LazyLoad可以有效的减少系统资源消耗,提高程序整体的性能,所以被广泛的使用,连Java的缺省类加载器也采用这种方法来加载Java类。
在 单线程环境下,一切都相安无事,但如果把上面的代码放到多线程环境下运行,那么就可能会出现问题。假设有2条线程,同时执行到了if(res == null),那么很有可能res被初始化2次,为了避免这样的Race Condition,得用synchronized关键字把上面的方法同步起来。代码如下:
代码2
Class
Foo {
Private Resource res = null
;
Public synchronized
Resource getResource() {
If (res == null
)
res = new
Resource();
return
res;
}
}
现在Race Condition解决了,一切都很好。
N 天过后,好学的你偶然看了一本Refactoring的魔书,深深为之打动,准备自己尝试这重构一些以前写过的程序,于是找到了上面这段代码。你已经不再 是以前的Java菜鸟,深知synchronized过的方法在速度上要比未同步的方法慢上100倍,同时你也发现,只有第一次调用该方法的时候才需要同 步,而一旦res初始化完成,同步完全没必要。所以你很快就把代码重构成了下面的样子:
代码3
Class
Foo {
Private Resource res = null
;
Public Resource getResource() {
If (res == null
){
synchronized
( this
){
if
(res == null
){
res = new
Resource();
}
}
}
return
res;
}
}
这种看起来很完美的优化技巧就是Double-Checked Locking。但是很遗憾,根据Java的语言规范,上面的代码是不可靠的。
造 成DCL失效的原因之一是编译器的优化会调整代码的次序。只要是在单个线程情况下执行结果是正确的,就可以认为编译器这样的“自作主张的调整代码次序”的 行为是合法的。JLS在某些方面的规定比较自由,就是为了让JVM有更多余地进行代码优化以提高执行效率。而现在的CPU大多使用超流水线技术来加快代码 执行速度,针对这样的CPU,编译器采取的代码优化的方法之一就是在调整某些代码的次序,尽可能保证在程序执行的时候不要让CPU的指令流水线断流,从而 提高程序的执行速度。正是这样的代码调整会导致DCL的失效。为了进一步证明这个问题,引用一下《DCL Broken Declaration》文章中的例子:
设一行Java代码:
Objects[i].reference = new Object ();
经过Symantec JIT编译器编译过以后,最终会变成如下汇编码在机器中执行:
0206106A mov eax,0F97E78h
0206106F call 01F6B210 ;为Object申请内存空间
; 返回值放在eax中
02061074 mov dword ptr [ebp],eax ; EBP 中是objects[i].reference的地址
; 将返回的空间地址放入其中
; 此时Object尚未初始化
02061077 mov ecx,dword ptr [eax] ; dereference eax所指向的内容
; 获得新创建对象的起始地址
02061079 mov dword ptr [ecx],100h ; 下面4行是内联的构造函数
0206107F mov dword ptr [ecx+4],200h
02061086 mov dword ptr [ecx+8],400h
0206108D mov dword ptr [ecx+0Ch],0F84030h
可见,Object构造函数尚未调用,但是已经能够通过objects[i].reference获得Object对象实例的引用。
如 果把代码放到多线程环境下运行,某线程在执行到该行代码的时候JVM或者操作系统进行了一次线程切换,其他线程显然会发现msg对象已经不为空,导致 Lazy load的判断语句if(objects[i].reference == null)不成立。线程认为对象已经建立成功,随之可能会使用对象的成员变量或者调用该对象实例的方法,最终导致不可预测的错误。
原 因之二是在共享内存的SMP机上,每个CPU有自己的Cache和寄存器,共享同一个系统内存。所以CPU可能会动态调整指令的执行次序,以更好的进行并 行运算并且把运算结果与主内存同步。这样的代码次序调整也可能导致DCL失效。回想一下前面对Java内存模型的介绍,我们这里可以把Main Memory看作系统的物理内存,把Thread Working Memory认为是CPU内部的Cache和寄存器,没有synchronized的保护,Cache和寄存器的内容就不会及时和主内存的内容同步,从而 导致一条线程无法看到另一条线程对一些变量的改动。
结合代码3来举例说明,假设Resource类的实现如下:
Class
Resource{
Object
obj;
}
即Resource类有一个obj成员变量引用了Object的一个实例。假设2条线程在运行,其状态用如下简化图表示:
图2
现 在Thread-1构造了Resource实例,初始化过程中改动了obj的一些内容。退出同步代码段后,因为采取了同步机制,Thread-1所做的改 动都会反映到主存中。接下来Thread-2获得了新的Resource实例变量res,由于没有使用synchronized保护所以Thread-2 不会进行刷新工作内存的操作。假如之前Thread-2的工作内存中已经有了obj实例的一份拷贝,那么Thread-2在对obj执行use操作的时候 就不会去执行load操作,这样一来就无法看到Thread-1对obj的改变,这显然会导致错误的运算结果。此外,Thread-1在退出同步代码段的 时刻对ref和obj执行的写入主存的操作次序也是不确定的,所以即使Thread-2对obj执行了load操作,也有可能只读到obj的初试状态的数 据。(注:这里的load/use均指JMM定义的操作)
有很多人不死心,试图想出了很多精妙的办法来解决这个问题,但最终都失败 了。事实上,无论是目前的JMM还是已经作为JSR提交的JMM模型的增强,DCL都不能正常使用。在William Pugh的论文《Fixing the java Memory Model》中详细的探讨了JMM的一些硬伤,更尝试给出一个新的内存模型,有兴趣深入研究的读者可以参见文后的参考资料。
如果你设计的对象在程序中只有一个实例,即singleton的,有一种可行的解决办法来实现其LazyLoad:就是利用类加载器的LazyLoad特性。代码如下:
Class
ResSingleton {
public
static
Resource res = new
Resource();
}
这里ResSingleton只有一个静态成员变量。当第一次使用ResSingleton.res的时候,JVM才会初始化一个Resource实例,并且JVM会保证初始化的结果及时写入主存,能让其他线程看到,这样就成功的实现了LazyLoad。
除了这个办法以外,还可以使用ThreadLocal来实现DCL的方法,但是由于ThreadLocal的实现效率比较低,所以这种解决办法会有较大的性能损失,有兴趣的读者可以参考文后的参考资料。
最 后要说明的是,对于DCL是否有效,个人认为更多的是一种带有学究气的推断和讨论。而从纯理论的角度来看,存取任何可能共享的变量(对象引用)都需要同步 保护,否则都有可能出错,但是处处用synchronized又会增加死锁的发生几率,苦命的程序员怎么来解决这个矛盾呢?事实上,在很多Java开源项 目(比如Ofbiz/Jive等)的代码中都能找到使用DCL的证据,我在具体的实践中也没有碰到过因DCL而发生的程序异常。个人的偏好是:不妨先大胆 使用DCL,等出现问题再用synchronized逐步排除之。也许有人偏于保守,认为稳定压倒一切,那就不妨先用synchronized同步起来, 我想这是一个见仁见智的问题,而且得针对具体的项目具体分析后才能决定。还有一个办法就是写一个测试案例来测试一下系统是否存在DCL现象,附带的光盘中 提供了这样一个例子,感兴趣的读者可以自行编译测试。不管结果怎样,这样的讨论有助于我们更好的认识JMM,养成用多线程的思路去分析问题的习惯,提高我 们的程序设计能力。
三、Java线程同步增强包
相 信你已经了解了Java用于同步的3板斧:synchronized/wait/notify,它们的确简单而有效。但是在某些情况下,我们需要更加复杂 的同步工具。有些简单的同步工具类,诸如ThreadBarrier,Semaphore,ReadWriteLock等,可以自己编程
实现。现在要介绍的是牛人Doug Lea的Concurrent包。这个包专门为实现Java高级并行程序所开发,可以满足我们绝大部分的要求。更令人兴奋的是,这个包公开源代码,可自由下载。且在JDK1.5中该包将作为SDK一部分提供给Java开发人员。
Concurrent Package提供了一系列基本的操作接口,包括sync,channel,executor,barrier,callable等。这里将对前三种接口及其部分派生类进行简单的介绍。
sync接口:
专门负责同步操作,用于替代Java提供的synchronized关键字,以实现更加灵活的代码同步。其类关系图如下:
图3 Concurrent包Sync接口类关系图
Semaphore:和前面介绍的代码类似,可用于pool类实现资源管理限制。提供了acquire()方法允许在设定时间内尝试锁定信号量,若超时则返回false。
Mutex:和Java的synchronized类似,与之不同的是,synchronized的同步段只能限制在一个方法内,而Mutex对象可以作为参数在方法间传递,所以可以把同步代码范围扩大到跨方法甚至跨对象。
NullSync: 一个比较奇怪的东西,其方法的内部实现都是空的,可能是作者认为如果你在实际中发现某段代码根本可以不用同步,但是又不想过多改动这段代码,那么就可以用 NullSync来替代原来的Sync实例。此外,由于NullSync的方法都是synchronized,所以还是保留了“内存壁垒”的特性。
ObservableSync:把sync和observer模式结合起来,当sync的方法被调用时,把消息通知给订阅者,可用于同步性能调试。
TimeoutSync:可以认为是一个adaptor,其构造函数如下:
public TimeoutSync(Sync sync, long timeout){…}
具体上锁的代码靠构造函数传入的sync实例来完成,其自身只负责监测上锁操作是否超时,可与SyncSet合用。
Channel接口:
代表一种具备同步控制能力的容器,你可以从中存放/读取对象。不同于JDK中的Collection接口,可以把Channel看作是连接对象构造者(Producer)和对象使用者(Consumer)之间的一根管道。如图所示:
图4 Concurrent包Channel接口示意图
通 过和Sync接口配合,Channel提供了阻塞式的对象存取方法(put/take)以及可设置阻塞等待时间的offer/poll方法。实现 Channel接口的类有 LinkedQueue,BoundedLinkedQueue,BoundedBuffer,BoundedPriorityQueue,SynchronousChannel,Slot 等。
图5 Concurrent包Channel接口部分类关系图
使用Channel我们可以很容易的编写具备消息队列功能的代码,示例如下:
代码4
Package
org.javaresearch.j2seimproved.thread;
Import EDU.oswego.cs.dl.util.concurrent.*;
public
class
TestChannel {
final
Channel msgQ = new
LinkedQueue(); //log信息队列
public
static
void
main( String
[] args) {
TestChannel tc = new
TestChannel();
For( int
i = 0;i < 10;i ++){
Try{
tc.serve();
Thread
.sleep(1000);
} catch
( InterruptedException
ie){
}
}
}
public
void
serve() throws
InterruptedException
{
String
status = doService();
//把doService()返回状态放入Channel,后台logger线程自动读取之
msgQ.put(status);
}
private
String
doService() {
// Do service here
return
"service completed OK! " ;
}
public
TestChannel() { // start background thread
Runnable
logger = new
Runnable
() {
public
void
run() {
try
{
for
(; ; )
System
.out.println( "Logger: " + msgQ.take());
}
catch
( InterruptedException
ie) {}
}
};
new
Thread
(logger).start();
}
}
Excutor/ThreadFactory接口:
把相关的线程创建/回收/维护/调度等工作封装起来,而让调用者只专心于具体任务的编码工作(即实现Runnable接口),不必显式创建Thread类实例就能异步执行任务。
使 用Executor还有一个好处,就是实现线程的“轻量级”使用。前面章节曾提到,即使我们实现了Runnable接口,要真正的创建线程,还是得通过 new Thread()来完成,在这种情况下,Runnable对象(任务)和Thread对象(线程)是1对1的关系。如果任务多而简单,完全可以给每条线程 配备一个任务队列,让Runnable对象(任务)和Executor对象变成n:1的关系。使用了Executor,我们可以把上面两种线程策略都封装 到具体的Executor实现中,方便代码的实现和维护。
具体的实现有: PooledExecutor,ThreadedExecutor,QueuedExecutor,FJTaskRunnerGroup等
类关系图如下:
图6 Concurrent包Executor/ThreadFactory接口部分类关系图
下面给出一段代码,使用PooledExecutor实现一个简单的多线程服务器
代码5
package
org.javaresearch.j2seimproved.thread;
import
java.net.*;
import
EDU.oswego.cs.dl.util.concurrent.*;
public
class
TestExecutor {
public
static
void
main( String
[] args) {
PooledExecutor pool =
new
PooledExecutor( new
BoundedBuffer(10), 20);
pool.createThreads(4);
try
{
ServerSocket
socket = new
ServerSocket
(9999);
for
(; ; ) {
final
Socket connection = socket.accept();
pool.execute( new
Runnable
() {
public
void
run() {
new
Handler ().process(connection);
}
});
}
}
catch
( Exception
e) {} // die
}
static
class
Handler {
void
process( Socket s){
}
}
}
限于篇幅,这里只是蜻蜓点水式的介绍了Concurrent包,事实上还有相当多有用的接口和类没有提到,我们的配套光盘中附带了Concurrent包和源代码,感兴趣的读者可以自行分析。
发表评论
-
BCD Conversion in java
2016-03-31 23:39 1853/** * Copyright 2010 Firat ... -
在java代码中获取JVM参数
2014-04-08 11:16 14271近日关注性能调优,关注JMX,发现java.lang.man ... -
GC日志分析配置与工具
2013-05-08 11:32 1370-verbose:gc(打印GC日志) -Xloggc:( ... -
java 实现HTTP PROXY
2012-12-06 17:21 7595日常应用中使用过很多次代理,主要停留在配置级别。 近期无意看 ... -
运行时获取方法调用堆栈信息(java)
2012-09-14 10:53 9707前几日系统流程回调时,一个方法莫名其妙被调用,无法定位调用点。 ... -
EL表达式在tomcat7.0下的new关键字不能使用
2012-08-24 17:25 4080最近生产系统部署个小应用,服务器选型tomcat7.0,一直运 ... -
xfire设置连接超时问题
2012-08-01 17:25 5163近期使用xfire作为客户端访问WS,结果因为目标主机假死 ... -
将多个对象写到一个文件
2012-07-20 17:08 1264来看一段ObjectOutputStream构造方法的源代码 ... -
多线程学习笔记:synchronized
2011-12-15 17:32 853Java语言的关键字,当它 ... -
(转)使用 Eclipse Memory Analyzer 检测内存泄漏问题
2011-12-14 18:10 1159本文是关于在开发 Talend RCP 过程中碰 ... -
多线程学习笔记:thread 线程中的sleep()、wait()、yield()、join()
2011-12-14 17:46 12901.sleep()方法 在指定时间内让当前正在执行的线程暂 ... -
jconsole监控JVM
2011-12-12 17:46 1578本地监控: Jconsole [processed] ... -
Java 6 JVM参数选项大全(中文版)
2011-11-03 15:19 1051本文 是基于最新的SUN官方 文档Java SE 6 ... -
Java实现远程屏幕监视
2011-10-19 17:40 744Robot robot = new Robot(); / ... -
java线程池 常用方法
2011-09-24 22:52 1400在Java5之后,并发线程这块发生了根本的变化,最重要的莫过于 ... -
JAVA 调用Web Service的方法
2011-08-15 10:28 11641.使用HttpClient 用到的jar文件:comm ... -
JVM监控工具--jvmstat
2011-08-02 15:42 1287首先就是下载这个工具链接:http://java.sun.co ... -
java性能优化
2011-07-18 15:19 1117一、避免在循环条件中 ... -
jvm内存参数设定
2011-07-17 20:30 1395在开发java应用时经常出 ... -
性能测试(并发负载压力)测试分析
2011-07-15 11:49 1741性能测试 (并发负载压力)测试分析 ...
相关推荐
- **Java heap space**: 堆是JVM管理的一部分内存,用于存储对象实例和数组。当堆内存无法满足新对象的分配需求时,就会抛出此异常。 **描述:“搜集整理关于java错误处理:java.lang.OutOfMemoryError: Java heap ...
为了解决这个问题,我们需要理解其背后的原因,并采取相应的措施来优化内存管理和配置。 #### 原因分析 1. **对象过度创建**:程序中存在过多的对象创建,尤其是在循环或递归过程中,如果对象未被及时垃圾回收,将...
资源名称:Java内存管理机制相关资料汇总资源目录:【】java内存回收机制及预防【】java内存管理机制【】java内存管理白皮书【】Java虚拟机内存管理_对象和引用_空指针【】深入理解java虚拟机jvm高级行与最佳实践...
尤其在内存管理方面,诸如内存泄漏、对象循环等问题严重影响了应用的稳定性和性能。针对这些问题,Quest JProbe 提供了一套完整的解决方案。本文档旨在帮助Java开发者快速掌握如何利用JProbe解决常见的Java内存问题...
Java是一种高性能、跨平台的面向...自动内存管理(垃圾回收): Java具有自动内存管理机制,通过垃圾回收器自动回收不再使用的对象,使得开发者不需要手动管理内存,减轻了程序员的负担,同时也减少了内存泄漏的风险。
### Java的内存分配详解 #### 一、Java内存模型概览 Java的内存管理是Java程序性能的关键之一。...通过本附录的学习,开发者可以更好地掌握Java内存管理的基本原理和技术,从而写出更加高效、稳定的Java应用程序。
通过对Java内存管理机制的深入分析,我们可以了解到Java如何高效地管理和利用内存资源。理解这些机制对于优化Java应用程序的性能至关重要,特别是在处理大规模数据集或多线程环境时。此外,合理配置JVM参数和选择...
Java内存管理是Java编程中的核心概念,它涉及到程序运行时数据的存储、分配以及回收。在Java中,内存主要分为堆内存(Heap)和栈内存(Stack),还有方法区(Method Area)、程序计数器(PC Register)以及本地方法...
Java内存管理是Java编程中至关重要的一环,它与C++等其他语言的内存管理机制有着显著的区别。在C++中,程序员需要手动管理内存,包括分配和释放,而在Java中,这一过程则由Java虚拟机(JVM)自动进行,通过垃圾收集...
Java内存管理是Java核心技术的重要组成部分,对于每个开发者来说,理解其工作原理都是十分必要的。这一主题既实用又有趣。以下是对Java内存管理的精彩概述,主要基于Sun Hotspot JVM,但请注意,不同JVM可能有不同的...
为了优化内存管理,Java采用了垃圾回收机制(Garbage Collection),自动回收不再使用的对象,以避免内存泄漏。 2. **Method Area(方法区)**:又称为非堆区或永久代,在这里存储的是类和接口的元数据,包括类的...
Java语言的一大卖点是它提供了自动内存管理,这意味着程序员不需要手动分配和释放内存,从而减少了内存泄漏和其他内存相关问题的风险。这一功能主要通过垃圾收集(Garbage Collection, GC)机制实现。本文将深入探讨...
在Windows操作系统中,内存管理是一个非常重要的方面。Windows实现按需调页的虚拟内存机制,使得应用程序可以使用超过物理内存容量的虚拟内存。此外,Windows还使用了页面文件来扩展物理内存的容量。 在Java中,...
然而,如同任何其他程序一样,Tomcat也可能遇到内存管理问题,导致内存溢出。"java.util.concurrent.ExecutionException: java.lang.OutOfMemoryError" 是一个典型的错误提示,它表明在并发执行过程中遇到了内存不足...
在Java应用程序运行过程中,"java.lang.OutOfMemoryError: PermGen space"错误是常见的一个问题,...对于任何内存管理问题,都需要深入理解应用程序的内存需求,并进行适当的监控和调优,以确保其稳定、高效地运行。
Java内存管理是编程中至关重要的一个环节,尤其是对于大型、长时间运行的应用来说,内存泄漏和内存无法回收可能导致系统性能下降,甚至导致系统崩溃。本文将深入探讨Java内存泄露的原理,分析内存无法回收的原因,并...
Java内存管理是Java编程中的核心概念,它涉及到程序运行时如何高效地分配、使用和回收内存。在Java中,内存管理主要由JVM(Java Virtual Machine)负责,其中包括了垃圾收集机制,确保程序不会因为内存泄漏而导致...
Java 中的内存管理机制是自动的,开发者不需要手动释放内存,但是这也使得 Java 程序占用内存相对较高。为了避免内存泄露,开发者需要注意在编写程序时,合理地使用内存资源。 Java 内存原理的优点: * 自动内存...