ImprovedList线程安全技术在实践中的应用

Question

我在实践中读过Java并发。它说这个类是线程安全的：

package net.jcip.examples;

import java.util.*;

import net.jcip.annotations.*;

/**
 * ImprovedList
 *
 * Implementing put-if-absent using composition
 *
 * @author Brian Goetz and Tim Peierls
 */
@ThreadSafe
public class ImprovedList<T> implements List<T> {
    private final List<T> list;

    public ImprovedList(List<T> list) { this.list = list; }

    public synchronized boolean putIfAbsent(T x) {
        boolean contains = list.contains(x);
        if (contains)
            list.add(x);
        return !contains;
    }

    // Plain vanilla delegation for List methods.
    // Mutative methods must be synchronized to ensure atomicity of putIfAbsent.

    public int size() {
        return list.size();
    }

    public boolean isEmpty() {
        return list.isEmpty();
    }

    public boolean contains(Object o) {
        return list.contains(o);
    }

    public Iterator<T> iterator() {
        return list.iterator();
    }

    public Object[] toArray() {
        return list.toArray();
    }

    public <T> T[] toArray(T[] a) {
        return list.toArray(a);
    }

    public synchronized boolean add(T e) {
        return list.add(e);
    }

    public synchronized boolean remove(Object o) {
        return list.remove(o);
    }

    public boolean containsAll(Collection<?> c) {
        return list.containsAll(c);
    }

    public synchronized boolean addAll(Collection<? extends T> c) {
        return list.addAll(c);
    }

    public synchronized boolean addAll(int index, Collection<? extends T> c) {
        return list.addAll(index, c);
    }

    public synchronized boolean removeAll(Collection<?> c) {
        return list.removeAll(c);
    }

    public synchronized boolean retainAll(Collection<?> c) {
        return list.retainAll(c);
    }

    public boolean equals(Object o) {
        return list.equals(o);
    }

    public int hashCode() {
        return list.hashCode();
    }

    public T get(int index) {
        return list.get(index);
    }

    public T set(int index, T element) {
        return list.set(index, element);
    }

    public void add(int index, T element) {
        list.add(index, element);
    }

    public T remove(int index) {
        return list.remove(index);
    }

    public int indexOf(Object o) {
        return list.indexOf(o);
    }

    public int lastIndexOf(Object o) {
        return list.lastIndexOf(o);
    }

    public ListIterator<T> listIterator() {
        return list.listIterator();
    }

    public ListIterator<T> listIterator(int index) {
        return list.listIterator(index);
    }

    public List<T> subList(int fromIndex, int toIndex) {
        return list.subList(fromIndex, toIndex);
    }

    public synchronized void clear() { list.clear(); }
}

我不这样认为。构造函数参数list可以在另一个线程中引用。因此，如果这个list不是线程安全的，那么它在并发性方面可能是不一致的。如果此list是线程安全的，则另一个线程使用list的锁操作它，而使用ImprovedList的线程使用ImprovedList对象锁来操作它，因此它们仍然可以并发地修改它。

谁能告诉我哪里错了？

Answer 1

书中的引文：

只要我们的类拥有对底层List的唯一未完成的引用，就可以保证提供线程安全。

因此，如果有人持有对同一列表的引用，则不能将该类称为线程安全。但你不认真阅读这本书是错误的。

Answer 2

你是对的。如果您想要使这样的列表真正“线程安全”，那么“传入”列表只是直接使用(例如不复制)，这一事实允许在任何其他对象的上下文中进行更改，这些对象包含对初始“传入”列表的引用。

除此之外，这个实现甚至允许对不同步的列表进行“硬修改”，如

public T remove(int index) {

所以-我同意你的评估；这看起来不太安全。在一定程度上是这样的，但是，“90%线程安全”，就像一个项目“完成了90%”一样，对吧？！

Answer 3

你错过了一个重要的观点：

ImprovedList假定，一旦将列表传递给其构造函数，客户端将不再直接使用基础列表，只通过ImprovedList访问它。

所以你加薪的用例在这里不适用。ImprovedList与Collections.synchronizedList(List)类似，它只是一个包装类，它防止使用内部锁对底层列表进行任何并发修改，因此，如果提供给构造函数的列表不是直接访问的，而是通过ImprovedList访问的，那么在这种情况下，它是线程安全的。

但是一般来说，如果您共享提供给构造函数的(非线程安全的) List，而不首先创建它的安全副本(知道创建非线程安全列表的安全副本并不是线程安全操作)，那么它就不再是线程安全的了。但是，请注意，共享一个非线程安全的List是一个错误，所以它并不是真正的生活用例。