Java并发编程——this引用逸出("this" Escape)

谁践踏了优雅 2022-09-26 12:59 172阅读 0赞

http://blog.csdn.net/flysqrlboy/article/details/10607295

并发编程实践中，this引用逃逸（"this"escape）是指对象还没有构造完成，它的this引用就被发布出去了。这是危及到线程安全的，因为其他线程有可能通过这个逸出的引用访问到“初始化了一半”的对象(partially-constructed object)。这样就会出现某些线程中看到该对象的状态是没初始化完的状态，而在另外一些线程看到的却是已经初始化完的状态，这种不一致性是不确定的，程序也会因此而产生一些无法预知的并发错误。在说明并发编程中如何避免this引用逸出之前，我们先看看一个对象是如何产生this引用逸出的。

一、this引用逸出是如何产生的

正如代码清单1所示，ThisEscape在构造函数中引入了一个内部类EventListener，而内部类会自动的持有其外部类（这里是ThisEscape）的this引用。 source.registerListener会将内部类发布出去，从而ThisEscape.this引用也随着内部类被发布了出去。但此时ThisEscape对象还没有构造完成 —— id已被赋值为1，但 name还没被赋值，仍然为null。

代码清单1 this引用逸出示例

**\[java\]** [view plain][] [copy][view plain]

1.  **public****class** ThisEscape \{ 
2.  
3.  **public****final****int** id; 
4.  **public****final** String name; 
5.  **public** ThisEscape(EventSource<EventListener> source) \{ 
6.   id = 1; 
7.   source.registerListener(**new** EventListener() \{ 
8.  **public****void** onEvent(Object obj) \{ 
9.   System.out.println("id: "\+ThisEscape.**this**.id); 
10.  System.out.println("name: "\+ThisEscape.**this**.name); 
11.  \} 
12.  \}); 
13.  name = "flysqrlboy"; 
14. 
15.  \} 
16.  \}

实际上，清单1中把内部类对象发布出去的source.registerListener语句没什么特殊的，从代码清单2可发现，registerListener方法只是往list中添加一个EventListener元素而已。这样，其他持有EventSource对象从而持有EventListener对象的线程，便可以访问ThisEscape的内部状态了（id和name）。代码清单3中的ListenerRunnable 就是这样的线程。

代码清单2 EventSource类

**\[java\]** [view plain][] [copy][view plain]

1.  **public****class** EventSource<T> \{ 
2.  
3.  **private****final** List<T> eventListeners ; 
4.  
5.  **public** EventSource() \{ 
6.   eventListeners = **new** ArrayList<T>() ; 
7.   \} 
8.  
9.  **public****synchronized****void** registerListener(T eventListener) \{ 
10. **this**.eventListeners.add(eventListener); 
11. **this**.notifyAll(); 
12.  \} 
13. 
14. **public****synchronized** List<T> retrieveListeners() **throws** InterruptedException \{ 
15.  List<T> dest = **null**; 
16. **if**(eventListeners.size() <= 0 ) \{ 
17. **this**.wait(); 
18.  \} 
19.  dest = **new** ArrayList<T>(eventListeners.size()); 
20.  dest.addAll(eventListeners); 
21. **return** dest; 
22.  \} 
23.  \}

代码清单3 ListenerRunnable 类

**\[java\]** [view plain][] [copy][view plain]

1.  **public****class** ListenerRunnable **implements** Runnable \{ 
2.  
3.  **private** EventSource<EventListener> source; 
4.  **public** ListenerRunnable(EventSource<EventListener> source) \{ 
5.  **this**.source = source; 
6.   \} 
7.  **public****void** run() \{ 
8.   List<EventListener> listeners = **null**; 
9.  
10. **try** \{ 
11.  listeners = **this**.source.retrieveListeners(); 
12.  \} **catch** (InterruptedException e) \{ 
13. // TODO Auto-generated catch block
14.  e.printStackTrace(); 
15.  \} 
16. **for**(EventListener listener : listeners) \{ 
17.  listener.onEvent(**new** Object()); 
18.  \} 
19.  \} 
20. 
21.  \}

代码清单4是个普通的消费线程的客户端程序，它先启动了一个ListenerRunnable 线程，用于监视ThisEscape的内部状态。紧接着调用ThisEscape的构造函数，新建一个ThisEscape对象。在ThisEscape构造函数中，如果在 source.registerListener语句之后，name="flysqrlboy"赋值语句之前正好发生上下文切换（如图1）， ListenerRunnable 线程就有可能看到了还没初始化完的ThisEscape对象--即id为1，但是name仍然为null！虽然正好在这个点上发生上下文切换是“偶然”事件，但理论上它是存在的。而这正是并发编程令人头疼的地方--平时好好的，但有时候就莫名其妙的失败了！而且还很难找出原因。为了使本例的this引用逸出容易被观察到，我们试图改造一下ThisEscape的构造函数（代码清单5），假设在source.registerListener和name赋值语句之间，还有其他的初始化操作，而且是比较耗时的。我们用一个sleep方法来模拟这样的耗时操作。经过这样的改造后，this引用逸出几乎是必然出现的--id等于1，name等于null。

代码清单4 ThisEscapeTest

**\[java\]** [view plain][] [copy][view plain]

1.  **public****class** ThisEscapeTest \{ 
2.  
3.  **public****static****void** main(String\[\] args) \{ 
4.   EventSource<EventListener> source = **new** EventSource<EventListener>(); 
5.   ListenerRunnable listRun = **new** ListenerRunnable(source); 
6.   Thread thread = **new** Thread(listRun); 
7.   thread.start(); 
8.   ThisEscape escape1 = **new** ThisEscape(source); 
9.   \} 
10. \}

图1 上下文切换

![Image 1][]

![20130830160101468][]

代码清单5 改造后的ThisEscape

**\[java\]** [view plain][] [copy][view plain]

1.  **public****class** ThisEscape \{ 
2.  
3.  **public****final****int** id; 
4.  **public****final** String name; 
5.  **public** ThisEscape(EventSource<EventListener> source) \{ 
6.   id = 1; 
7.   source.registerListener(**new** EventListener() \{ 
8.  **public****void** onEvent(Object obj) \{ 
9.   System.out.println("id: "\+ThisEscape.**this**.id); 
10.  System.out.println("name: "\+ThisEscape.**this**.name); 
11.  \} 
12.  \}); 
13. **try** \{ 
14.  Thread.sleep(1000); // 调用sleep模拟其他耗时的初始化操作
15.  \} **catch** (InterruptedException e) \{ 
16. // TODO Auto-generated catch block
17.  e.printStackTrace(); 
18.  \} 
19.  name = "flysqrlboy"; 
20. 
21.  \} 
22. \}

二、如何避免this引用逸出

上文演示了由内部类导致的this引用逸出是怎样产生的。它需要满足两个条件：一个是在构造函数中创建内部类(EventListener)，另一个是在构造函数中就把这个内部类给发布了出去(source.registerListener)。因此，我们要防止这一类this引用逸出的方法就是避免让这两个条件同时出现。也就是说，如果要在构造函数中创建内部类，那么就不能在构造函数中把他发布了，应该在构造函数外发布，即等构造函数执行完毕，初始化工作已全部完成，再发布内部类。正如清单6所示的那样，使用一个私有的构造函数进行初始化和一个公共的工厂方法进行发布。

代码清单6 安全的构建以防止this引用逸出

**\[java\]** [view plain][] [copy][view plain]

1.  **public****class** ThisSafe \{ 
2.  
3.  **public****final****int** id; 
4.  **public****final** String name; 
5.  **private****final** EventListener listener; 
6.  
7.  **private** ThisSafe() \{ 
8.   id = 1; 
9.   listener = **new** EventListener()\{ 
10. **public****void** onEvent(Object obj) \{ 
11.  System.out.println("id: "\+ThisSafe.**this**.id); 
12.  System.out.println("name: "\+ThisSafe.**this**.name); 
13.  \} 
14.  \}; 
15.  name = "flysqrlboy"; 
16.  \} 
17. 
18. **public****static** ThisSafe getInstance(EventSource<EventListener> source) \{ 
19.  ThisSafe safe = **new** ThisSafe(); 
20.  source.registerListener(safe.listener); 
21. **return** safe; 
22.  \} 
23. 
24. 
25. \}

另一种导致this引用逸出的常见错误，是在构造函数中启动一个线程。其原理跟上文说的内部类导致的this引用逸出相类似。解决的办法也相似，即可以在构造函数中创建线程，但别启动它。在构造函数外面再启动。

[view plain]: http://blog.csdn.net/flysqrlboy/article/details/10607295#
[Image 1]: 
[20130830160101468]: /images/20220717/3c081c7df9e345818ae54e0fd2147ef7.png

发表评论取消回复

表情：

评论列表（有 0 条评论，172人围观）

还没有评论，来说两句吧...

相关阅读

相关 java中构造方法及this引用

一、构造方法分类默认构造方、带参数的构造方法。二、构造方法的定义（1）构造方法的主要作用是进行一些数据的初始化。当类创建一个对象时会自动调用该类的构造方法

女爷i/ 2024年03月26日 19:24/ 0 赞/ 79 阅读

相关简便理解this引用

首先要理解this我们需要先提出一个问题？ public class Data { public int year; public i

古城微笑少年丶/ 2024年03月26日 18:51/ 0 赞/ 64 阅读

相关 java并发编程实践学习（四）对象的发布和逸出之this逃逸

原文来源： https://blog.csdn.net/aitangyong/article/details/25122741 《java并发编程实践》的第三章，对象的发布

红太狼/ 2024年02月19日 16:55/ 0 赞/ 27 阅读

相关 Java并发编程之this逃逸问题

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zhushuai1221/article/details/51221552

Dear 丶/ 2024年02月19日 16:55/ 0 赞/ 48 阅读

相关 Java中关键字 this 引用

Java中关键字 : this 引用文章目录 Java中关键字 : this 引用为什么要有this引用

迷南。/ 2023年10月04日 18:37/ 0 赞/ 65 阅读

相关【Java基础】This逃逸（This引用逃逸详解）

【Java基础】This逃逸（ This引用逃逸详解） 1、This逃逸中的关键词 This引用逃逸对象在还没有构造完成时，This引

亦凉/ 2023年09月27日 21:58/ 0 赞/ 119 阅读

相关 java this引用逃逸

上代码！！！！！！！！！！ public class FinalReferenceEscapeExample { final int i;

向右看齐/ 2022年12月28日 01:53/ 0 赞/ 140 阅读

相关并发编程this逸出

并发编程实践中，this引用逃逸（"this"escape）是指对象还没有构造完成，它的this引用就被发布出去了。这是危及到线程安全的，因为其他线程有可能通过这个逸出的引用访

清疚/ 2022年11月17日 05:30/ 0 赞/ 122 阅读

相关 Java并发编程——this引用逸出("this" Escape)

http://blog.csdn.net/flysqrlboy/article/details/10607295 并发编程实践中，this引用逃逸（"this"escap

谁践踏了优雅/ 2022年09月26日 12:59/ 0 赞/ 173 阅读

相关 this引用逃逸

什么是this引用逃逸指的是对象还没有构造完成，他的this引用就已经发布出去了。先确定两个名词定义，对象的发布与逸出。发布：发布一个对象的意思是指，使对象

谁借莪１个温暖的怀抱￠/ 2022年05月18日 03:14/ 0 赞/ 150 阅读