Java：引用转义

IT小君 2021-12-11T06:07:21

阅读以下代码是“不安全构造”的示例，因为它允许此引用转义。我不太明白“这个”是如何逃脱的。我对 Java 世界很陌生。任何人都可以帮助我理解这一点。

public class ThisEscape {
    public ThisEscape(EventSource source) {
        source.registerListener(
            new EventListener() {
                public void onEvent(Event e) {
                    doSomething(e);
                }
            });
    }
}

IT小君

您在问题中发布的示例来自Brian Goetz 等人的“Java Concurrency In Practice”。它在第 3.2 节“发布和逃逸”中。我不会尝试在此处重现该部分的详细信息。（去为你的书架买一本，或者从你的同事那里借一本！）

示例代码说明的问题是构造函数允许对正在构造的对象的引用在构造函数完成创建对象之前“转义”。这是一个问题，原因有两个：

如果引用转义，则某些对象可以在其构造函数完成初始化之前使用该对象，并看到它处于不一致（部分初始化）状态。即使对象在初始化完成后转义，声明子类也会导致违反这一点。
根据JLS 17.5，可以安全地使用对象的最终属性而无需同步。但是，这仅在对象引用在其构造函数完成之前未发布（不转义）时才成立。如果你打破这个规则，结果是一个潜在的并发错误，当代码在多核/多处理器机器上执行时，它可能会咬你。

这个ThisEscape例子是偷偷摸摸的，因为引用是this通过隐式传递给匿名EventListener类构造函数的引用进行转义的。但是，如果过早明确地发布参考文献，也会出现同样的问题。

下面是一个例子来说明对象初始化不完全的问题：

public class Thing {
    public Thing (Leaker leaker) {
        leaker.leak(this);
    }
}

public class NamedThing  extends Thing {
    private String name;

    public NamedThing (Leaker leaker, String name) {
        super(leaker);

    }

    public String getName() {
        return name; 
    }
}

如果该Leaker.leak(...)方法调用getName()泄漏的对象，它将得到null... 因为在那个时间点对象的构造函数链还没有完成。

这里有一个例子来说明final属性的不安全发布问题。

public class Unsafe {
    public final int foo = 42;
    public Unsafe(Unsafe[] leak) {
        leak[0] = this;   // Unsafe publication
        // Make the "window of vulnerability" large
        for (long l = 0; l < /* very large */ ; l++) {
            ...
        }
    }
}

public class Main {
    public static void main(String[] args) {
        final Unsafe[] leak = new Unsafe[1];
        new Thread(new Runnable() {
            public void run() {
                Thread.yield();   // (or sleep for a bit)
                new Unsafe(leak);
            }
        }).start();

        while (true) {
            if (leak[0] != null) {
                if (leak[0].foo == 42) {
                    System.err.println("OK");
                } else {
                    System.err.println("OUCH!");
                }
                System.exit(0);
            }
        }
    }
}

此应用程序的某些运行可能会打印“哎哟！” 而不是“OK”，表明Unsafe由于通过leak数组不安全的发布，主线程已经观察到处于“不可能”状态的对象。这是否发生将取决于您的 JVM 和您的硬件平台。

现在这个例子显然是人为的，但不难想象这种事情在真正的多线程应用中是如何发生的。

^{作为 JSR 133 的结果，当前的 Java 内存模型在 Java 5（JLS 的第 3 版）中指定。在此之前，Java 与内存相关的方面没有详细说明。引用早期版本/版本的来源已过时，但 Goetz 版本 1 中有关内存模型的信息是最新的。}

^{内存模型的一些技术方面显然需要修改；请参阅https://openjdk.java.net/jeps/188和https://www.infoq.com/articles/The-OpenJDK9-Revised-Java-Memory-Model/。但是，这项工作尚未出现在 JLS 修订版中。}

2021-12-11T06:07:21 回复

IT小君

我也有同样的疑问。

问题是，在其他类中实例化的每个类都引用了变量中的封闭类$this。

这就是 java 所说的合成，它不是你定义的东西，而是 java 自动为你做的事情。

如果您想亲自查看此内容，请在该doSomething(e)行中放置一个断点并检查EventListener具有哪些属性。

2021-12-11T06:07:21 回复

IT小君

我的猜测是该doSomething方法是在ThisEscape类中声明的，在这种情况下，引用肯定可以“逃脱”。
即，某些事件可以EventListener在其创建之后和ThisEscape构造函数执行完成之前立即触发。反过来，侦听器将调用的实例方法ThisEscape。

我会稍微修改一下你的例子。现在变量var可以doSomething在构造函数中分配之前在方法中访问。

public class ThisEscape {
    private final int var;

    public ThisEscape(EventSource source) {
        source.registerListener(
            new EventListener() {
                public void onEvent(Event e) {
                    doSomething(e);
                }
            }
        );

        // more initialization
        // ...

        var = 10;
    }

    // result can be 0 or 10
    int doSomething(Event e) {
        return var;
    }
}

2021-12-11T06:07:22 回复

IT小君

我在阅读Brian Goetz 的“ Java 并发实践”时遇到了完全相同的问题。

Stephen C的回答（已接受的回答）非常好！我只想在我发现的另一种资源之上添加。它来自JavaSpecialists，Heinz M. Kabutz 博士准确地分析了devnull发布的代码示例。他解释了编译this后生成了哪些类（外部、内部）以及如何转义。我发现这个解释很有用，所以我想分享 :)

issue192（他扩展了示例并提供了竞争条件。）

issue192b（他解释了编译后生成了什么样的类以及如何this转义。）

2021-12-11T06:07:22 回复