这个类线程安全吗？如果没有，有人可以解释一个场景吗？

Question

我正在尝试了解有效不可变类的安全发布。对于我的班级，我无法想出线程不安全的场景。我需要添加一些其他的安全防护吗？

澄清：容器元素是线程安全的

 public class Container<E> {
    private LinkedList<E> data;

     public Container() {
        this.data = new LinkedList<E>();
    }

    public Container(final Container<E> other) {
        this.data = new LinkedList<E>(other.data);
    }

    public Container<E> add(E e) {
        Container<E> other_cont= new Container<E>(this);
        other_cont.data.add(e);
        return other_cont;
    }

    public Container<E> remove() {
        Container<E> other_cont= new Container<E>(this);
        other_cont.data.remove(0);
        return other_cont;
    }

     public E peek() {
        if(this.data.isEmpty())
            throw new NoSuchElementException("No element to peek at");
        return this.data.get(0);
    }

     public int size() {
        return this.data.size();
    }
 }

Answer 1

这看起来不错，只要 Container 没有不安全地发布（无论如何我们都不应该这样做）。

但是，为了便于讨论，假设一个 Container 对象是通过不安全发布传递的

 static Container shared; // not volatile

 // thread 1
 shared = containerX.add( e );

 // thread 2
 shared.peek();

这不是线程安全的；线程 2 可以观察到损坏状态。

要解决这个问题，我们需要final 变量；并且所有写入都应该在构造函数退出之前完成。在您的代码中，您在new Container 之后修改了other_cont，这就是问题所在。

就我个人而言，我会这样做

 public class Container<E> {
    final private LinkedList<E> data;

    public Container() {
        this.data = new LinkedList<E>();
    }

    Container(LinkedList<E> data) {
        this.data = data;
    }

    public Container<E> add(E e) {

        LinkedList<E> copy = new LinkedList<>(data); 
        copy.add( e );
        return new Container<>(copy);
    }

    ... etc

设计不可变类的经验法则 - 所有字段必须是final，并且所有写入都必须在构造函数退出之前完成。