java并发-同步容器类

Posted 2020-09-22 lwli

　　java平台类库包含了丰富的并发基础构建模块，如线程安全的容器类以及各种用于协调多个相互协作的线程控制流的同步工具类。

同步容器类

　　同步容器类包括Vector和Hashtable，是早期JDK的一部分，此外还有Collections.synchronizedXXX等工厂方法创建的。这些类实现安全的方式是，将他们的状态封装起来，并对每个public方法进行同步，从而 使得每次只有一个线程能访问容器的状态。

　　同步容器类都是线程安全的，但是对于某些复合操作需要额外的加锁来保护。常见复合操作有：迭代（反复访问元素，直到遍历所有元素）、跳转（根据指定顺序找到当期元素的下一个元素）以及条件运算（如：如没有则添加）。

public static Object getLast(Vector list){
    int lastIndex = list.size() - 1;
    return list.get(lastIndex)
}

public static void deleteLast(Vector list){
    int lastIndex = list.size() - 1;
    list.remove(lastIndex);
}

　　上面例子中，Vector中定义了两个方法，它们都执行先检查再运行操作。先获取数组大小，再获取或删除最后一个元素。这些方法看似没问题，并且都是线程安全的，也不破坏Vector。但是从调用者角度来看，就有问题了。可能A线程调用getLast的过程中，B线程调用了deleteLast，Vector元素减少，导致A线程调用失败。

　　同步容器类遵守同步策略，即支持客户端加锁，因此只要我们知道应该使用那个锁，就能创建一些新的操作。这些新操作与容器与其他操作都是原子操作。同步容器通过自身的锁来保护它的每个方法。通过获取容器的锁，就能使上面的方法称为原子操作。size和get操作之间不会有其他操作。

public static Object getLast(Vector list){
    synchronized(list){
        int lastIndex = list.size() - 1;
        return list.get(lastIndex)
    }
    
}

public static void deleteLast(Vector list){
    synchronized(list){
        int lastIndex = list.size() - 1;
        list.remove(lastIndex);
    }
}

　　同样的问题也会出现在遍历上，如下面的例子：

for(int i=0; i< vector.size(); i++)
    doSomgthing(vector.get(i));

　　如果另外一个线程删除一个元素，会导致ArrayIndexOutBoundsException异常。我们可以通过加锁来解决迭代不可靠问题，避免其他线程在遍历过程修改Vector。但也带来性能问题，迭代期间其他线程无法访问它。

synchronized(vector){
    for(int i=0; i< vector.size(); i++)
        doSomgthing(vector.get(i));
}

　　上面的例子在未加锁的情况下都可能抛出异常，这并不意味着Vector不是线程安全的。Vector仍然是线程安全的，抛出的异常也与其规范保持一致。

迭代器与ConcurrentModificationException

　　对容器进行迭代的标准方式是使用Iterator，使用for-each语法，也是调用Iterator。在设计同步容器类的时候并没有考虑并发修改问题，它们表现出的行为是“及时失败”的，意味着在迭代过程中，如果有其他线程修改容器，会抛出ConcurrentModificationException异常。它们实现的方式是，将计数器变化与容器关联起来，放迭代器件计数器被修改，那么hasNext或next将抛出异常。这是设计上的一个权衡。

　　要想避免ConcurrentModificationException，就必须在迭代过程持有容器的锁。但是如果容器规模很大，迭代过程持有锁，将导致严重的性能问题。一种替代方式就是“克隆容器”，并在副本上迭代。克隆过程仍然需要加锁，同时存在显著的性能开销。克隆容器的好坏取决于过个元素，如容器大小，迭代时，每个元素执行的操作等。

隐藏迭代器

　　加锁可以防止迭代抛出ConcurrentModificationException异常，但是需要在所有迭代的地方进行加锁。实际情况通常更加复杂，有些情况下可能会忽略隐藏的迭代器。

　　

public class HiddenIterator{
    private final Set(Integer) set = new HashSet<>();
    
    public synchronized void add(Integer i){set.add(i)}
    public synchronized void remove(Integer i){set.remove(i)}
    
    public void addTenThings(){
        Random r = new Random();
        for(int i=0;i<10;i++){
            add(r.nextInt());
        }
        System.out.println("debug" + set)
    }
}

　　addTenThings方法可能抛出ConcurrentModificationException异常，因为在打印输出的时候进行字符串连接，会调用set的toString方法，toString方法会对容器进行迭代。在使用println前必须获取HiddenIterator的锁，但是实际应用中可能忽略。

　　封装对象的状态有助于维持不变性，封装对象的同步机制有助有确保实施同步策略。

　　如果使用synchronizedSet来包装HashSet，并且对同步代码进行封装，就不会发生这种错误。

　　除了toString，hashCode和equals等方法也会间接执行迭代操作。当容器作为另一个容器的元素和键值时，就会出现这种情况。同样，containsAll，removeAll等方法，以及把容器作为参数的构造函数都会对容器进行迭代。这些间接操作都有可能抛出ConcurrentModificationException异常。