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

谁践踏了优雅 2022-09-26 12:59 156阅读 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 条评论，156人围观）

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

相关阅读

相关新手疑惑：Java中的this引用是什么？

在Java编程中，`this`通常是一个关键字，它被用来引用当前对象自身。简单来说，当你在一个方法或者构造器内部声明一个变量，并且想要使用这个对象自身的某个属性时，就会用到`t

末蓝、/ 2024年10月23日 12:12/ 0 赞/ 34 阅读

相关新手疑惑：为什么Java的this引用不明确？

在Java中，`this`关键字通常用于引用当前对象的方法或属性。虽然它看起来像是一个明确的引用，但在某些情况下，它的明确性可能会被质疑。以下几点可能导致`this`引用不

深碍√TFBOYSˉ_/ 2024年09月13日 14:15/ 0 赞/ 138 阅读

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

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

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

相关 java this引用逃逸

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

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

相关并发编程this逸出

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

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

相关 java逸出_java内存模型-final

标签：与前面介绍的锁和 volatile 相比较，对 final 域的读和写更像是普通的变量访问。对于final 域，编译器和处理器要遵守两个重排序规则：在构造函数内对

分手后的思念是犯贱/ 2022年11月09日 06:02/ 0 赞/ 175 阅读

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

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

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

相关 this引用逃逸

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

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

相关 Java中this表示当前对象的引用

一、 this有两种使用情况，一种就是直接使用“this.属性名”或者“this.方法名()”，另外一种是“this()”。二、使用this实现构造方法的

骑猪看日落/ 2021年12月05日 00:53/ 0 赞/ 232 阅读

相关 var $this = $(this)

[jQuery: What’s the Difference Between $(this), $this, and this?][jQuery_ What_s the Di

亦凉/ 2021年11月29日 18:56/ 0 赞/ 268 阅读