Question

我正在关注 Java Concurrency in Practice ，当我读到堆栈限制时，我觉得很好，因为它解释得很好，但这句话给我带来了一些疑问：

维护对象引用的堆栈限制需要一点点程序员提供更多帮助以确保指示对象的帮助不逃避

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

/**
 * 
 */
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

这句话对我提出了一些疑问：


维护对象引用的堆栈限制需要一点点     程序员提供更多帮助以确保指示对象的帮助     不逃避


任何人都可以在下面的代码中执行某些操作来产生违反堆栈的行为   约束

当然。如果这不是一件事，那么Goetz 等。首先不会把时间花在堆栈限制上。

我猜它目前没有限制违规。一世想知道本地对象引用如何违反限制。

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

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

实际上有很多方法可以将特定于代码的限制违规行为引入您的特定代码，但是如何：假设我想让StackConfinement.setSomeMoreProperty()实际上具有持久效果，例如放置{ {1}}它生成的对象为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）都没有堆栈限制。

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

1 个答案: