java - 使用本地对象引用的堆栈限制

Question

我正在关注实践中的 Java 并发，当我读到有关堆栈限制的内容时，我感觉很好，因为它解释得很好，但这个说法给我带来了一些疑问:

Maintaining stack confinement for object references requires a little more assistance from the programmer to ensure that the referent does not escape

任何人都可以在下面的代码中执行某些操作来违反堆栈限制吗？我猜目前没有违反禁闭规定。我想知道本地对象引用如何违反限制。

/**
 * 
 */
package lession2.shared.object;

/**
 * @author so_what
 */
class Person {
    private String personName;
    private String personAddress;

    public String getPersonName() {
        return personName;
    }

    public void setPersonName(String personName) {
        this.personName = personName;
    }

    public String getPersonAddress() {
        return personAddress;
    }

    public void setPersonAddress(String personAddress) {
        this.personAddress = personAddress;
    }

    @Override
    public String toString() {
        return "Person [personName=" + personName + ", personAddress=" + personAddress + "]";
    }
}

public class StackConfinement extends Thread {

    public void setSomeMoreProperty() {
        //this person object will be confined to each thread
        Person person=new Person();
        person.setPersonAddress("NY");
        person.setPersonName("Xyz");
        //now I wan to pass this person to the other method
        doSomething(person);
        System.out.println(person);
    }

    public void doSomething(Person person) {
        person.setPersonAddress("Canada");
        //can one add some thing here and violate the thread confinement
    }   

    @Override
    public void run()
    {
        setSomeMoreProperty();
    }

    public static void main(String[] args) throws InterruptedException {
        StackConfinement thread1=new StackConfinement();
        StackConfinement thread2=new StackConfinement();
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }

}

Answer 1

this statement raised some doubts for me:

Maintaining stack confinement for object references requires a little more assistance from the programmer to ensure that the referent does not escape

任何人都可以在下面的代码中执行某些操作来产生堆栈冲突 坐月子？

当然。如果这不是一件事，那就是 Goetz 等人。一开始就不会花时间在堆栈限制上。

I guess it has no confinement violation at present. I want to know how local object reference can violate the confinement.

存储在局部变量中的引用不会违反堆栈限制，本书将堆栈限制定义为只能通过局部变量访问对象的情况。当存在对更广泛可访问的对象的(另一个)引用时，就会出现问题。例如，如果您将对象的引用存储在任何类的静态字段中，就会发生这种情况。如果您将对对象的引用存储在本身不受堆栈限制的容器中，也会发生这种情况。

这本书给出了一个更微妙的例子，其中引用存储在一个容器中，该容器本身最初是堆栈限制的，但后来被发布。由于该对象可以从(不再受堆栈限制)容器访问，因此它也不再受堆栈限制。

实际上有无数种方法可以将堆栈限制违规引入到您的特定代码中，但是这个怎么样:假设我想制作 StackConfinement.setSomeMoreProperty()实际上有一个持久的效果，比如把Person它生成的对象为 List 。看起来像这样:

public class StackConfinement extends Thread {

    private List<Person> people = new ArrayList<>();

    public void setSomeMoreProperty() {
        // Initially stack-confined
        Person person = new Person();

        person.setPersonAddress("NY");
        person.setPersonName("Xyz");

        // does not break stack confinement:
        doSomething(person);
        System.out.println(person);

        // this DOES break stack confinement:
        people.add(person);
    }

    // ...
}

这一切都很好，但现在 people 都不是了。成员或其引用的任何对象(例如 person 添加的 setSomeMoreProperty() )都是堆栈限制的。