Java并发 - 同步容器篇

亦凉 2022-10-16 13:19 181阅读 0赞

### 文章目录 ###

*  简介
 *  目录
 *  正文
 *   *   *  1 . 什么是同步容器
         *  2. 为什么要有同步容器
         *  3. 同步容器的优缺点
         *  4. 同步容器的使用场景
 *  总结

--------------------

# 简介 #

同步容器主要分两类，一种是Vector这样的普通类，一种是通过Collections的工厂方法创建的内部类

虽然很多人都对同步容器的性能低有偏见，但它也不是一无是处，在这里我们插播一条阿里巴巴的开发手册规范：

> 高并发时，同步调用应该去考量锁的性能损耗。能用无锁数据结构，就不要用锁；能锁区块，就不要锁整个方法体；能用对象锁，就不要用类锁。

可以看到，只有在高并发才会考虑到锁的性能问题，所以在一些小而全的系统中，同步容器还是有用武之地的（当然也可以考虑并发容器，后面章节再讨论）

# 目录 #

我们这里分这么几步来分析：

1.  什么是同步容器
2.  为什么要有同步容器
3.  同步容器的优缺点
4.  同步容器的使用场景

# 正文 #

### 1 . 什么是同步容器 ###

定义：就是把容器类同步化，这样我们在并发中使用容器时，就不用手动同步，因为内部已经自动同步了

例子：比如Vector就是一个同步容器类，它的同步化就是把内部的所有方法都上锁（有的重载方法没上锁，但是最终调用的方法还是有锁的）

**源码：Vector.add**

// 通过synchronized为add方法上锁
    public synchronized boolean add(E e) { 
      modCount++;
      ensureCapacityHelper(elementCount + 1);
      elementData[elementCount++] = e;
      return true;
    }

同步容器主要分两类：

1.  **普通类**：Vector、Stack、HashTable
2.  **内部类**：Collections创建的内部类，比如Collections.SynchronizedList、 Collections.SynchronizedSet等

那这两种有没有区别呢？

当然是有的，刚开始的时候(Java1.0)只有第一种同步容器(Vector等)

但是因为Vector这种类太局气了，它就想着把所有的东西都弄过来自己搞(Vector通过toArray转为己有,HashTable通过putAll转为己有）；

**源码：Vector构造函数**

public Vector(Collection<? extends E> c) { 
    	// 这里通过toArray将传来的集合 转为己有
      elementData = c.toArray();
      elementCount = elementData.length;
      // c.toArray might (incorrectly) not return Object[] (see 6260652)
      if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

所以就有了第二种同步容器类(通过工厂方法创建的内部容器类)，它就比较聪明了，它只是把原有的容器进行包装（通过this.list = list直接指向需要同步的容器)，然后局部加锁，这样一来，即生成了线程安全的类，又不用太费力；

**源码：** Collections.SynchronizedList构造函数

SynchronizedList(List<E> list) { 
      super(list);
      // 这里只是指向传来的list，不转为己有，后面的相关操作还是基于原有的list集合
      this.list = list;
    }

它们之间的区别如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xpX0ppYW5fSHVpXw_size_16_color_FFFFFF_t_70]

这里我们重点说下锁的对象：

*  **普通类**锁的是**当前对象this**（锁在方法上，默认this对象）；
 *  **内部类**锁的是**mutex**属性，这个属性默认是**this**，但是可以通过**构造函数**（或工厂方法）来**指定锁**的对象；

**源码：** Collections.SynchronizedCollection构造函数

final Collection<E> c;  // Backing Collection
    // 这个就是锁的对象
    final Object mutex;     // Object on which to synchronize
    
    SynchronizedCollection(Collection<E> c) { 
      this.c = Objects.requireNonNull(c);
    // 初始化为 this
      mutex = this;
    }
    
    SynchronizedCollection(Collection<E> c, Object mutex) { 
      this.c = Objects.requireNonNull(c);
      this.mutex = Objects.requireNonNull(mutex);
    }

> 这里要注意一点就是，内部类的迭代器没有同步(Vector的迭代器有同步），需要手动加锁来同步

**源码：** Vector.Itr.next 迭代方法（有上锁）

public E next() { 
      synchronized (Vector.this) { 
        checkForComodification();
        int i = cursor;
        if (i >= elementCount)
          throw new NoSuchElementException();
        cursor = i + 1;
        return elementData(lastRet = i);
      }
    }

**源码**：Collections.SynchronizedCollection.iterator 迭代器（没上锁）

public Iterator<E> iterator() { 
      // 这里会直接实现类的迭代器（比如ArrayList，它里面的迭代器肯定是没上锁的）
      return c.iterator(); // Must be manually synched by user!
    }

### 2. 为什么要有同步容器 ###

因为普通的容器类（比如ArrayList)是线程不安全的，如果是在并发中使用，我们就需要手动对其加锁才会安全，这样的话就很麻烦；

所以就有了同步容器，它来帮我们自动加锁

下面我们用代码来对比下

**线程不安全的类：** ArrayList

public class SyncCollectionDemo { 
        
        private List<Integer> listNoSync;
    
        public SyncCollectionDemo() { 
            this.listNoSync = new ArrayList<>();
        }
    
        public void addNoSync(int temp){ 
            listNoSync.add(temp);
        }
    
        public static void main(String[] args) throws InterruptedException { 
            SyncCollectionDemo demo = new SyncCollectionDemo();
    				// 创建10个线程
            for (int i = 0; i < 10; i++) { 
    					// 每个线程执行100次添加操作
              new Thread(()->{ 
                    for (int j = 0; j < 1000; j++) { 
                        demo.addNoSync(j);
                    }
                }).start();
            }
        }
    }

上面的代码看似没问题，感觉就算有问题也应该是插入的顺序比较乱（多线程交替插入）

但实际上运行会发现，可能会报错数组越界，如下所示：

![在这里插入图片描述][20210530140024412.png]

原因有二：

1.  因为ArrayList.add操作没有加锁，导致多个线程可以同时执行add操作
2.  add操作时，如果发现list的容量不足，会进行扩容，但是由于多个线程同时扩容，就会出现扩容不足的问题

**源码：** ArrayList.grow扩容

// 扩容方法
    private void grow(int minCapacity) { 
            // overflow-conscious code
            int oldCapacity = elementData.length;
    				// 这里可以看到，每次扩容增加一半的容量
      			int newCapacity = oldCapacity + (oldCapacity >> 1);
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
        }

可以看到，扩容是基于之前的容量进行的，因此如果多个线程同时扩容，那扩容基数就不准确了，结果就会有问题

**线程安全的类**：Collections.SynchronizedList

public class SyncCollectionDemo { 
    
        private List<Integer> listSync;
    
        public SyncCollectionDemo() { 
          	// 这里包装一个空的ArrayList
            this.listSync = Collections.synchronizedList(new ArrayList<>());
        }
    
        public void addSync(int j){ 
          	// 内部是同步操作: synchronized (mutex) {return c.add(e);}
            listSync.add(j);
        }
    
        public static void main(String[] args) throws InterruptedException { 
            SyncCollectionDemo demo = new SyncCollectionDemo();
    
            for (int i = 0; i < 10; i++) { 
                new Thread(()->{ 
                    for (int j = 0; j < 100; j++) { 
                        demo.addSync(j);
                    }
                }).start();
            }
    
            TimeUnit.SECONDS.sleep(1);
          	// 输出1000
            System.out.println(demo.listSync.size());
        }
    }

输出正确，因为现在ArrayList被Collections包装成了一个线程安全的类。

这就是为啥会有同步容器的原因：因为同步容器使得并发编程时，线程更加安全。

### 3. 同步容器的优缺点 ###

优点：

*  并发编程中，独立操作是线程安全的，比如单独的add操作
 *  性能差，基本上所有方法都上锁，完美的诠释了“宁可错杀一千，不可放过一个”
 *  复合操作，还是不安全，比如putIfAbsent操作（如果没有则添加）
 *  快速失败机制，这种机制会报错提示ConcurrentModificationException，一般出现在当某个线程在遍历容器时，其他线程恰好修改了这个容器的长度

为啥第三点是缺点呢？

因为它只能作为一个建议，告诉我们有并发修改异常，但是不能保证每个并发修改都会爆出这个异常。

爆出这个异常的前提如下：

**源码**：Vector.Itr.checkForComodification 检查容器修改次数

final void checkForComodification() { 
      // modCount：容器的长度变化次数， expectedModCount：期望的容器的长度变化次数
      if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    }

那什么情况下并发修改不会爆出异常呢？有两种：

1.  遍历没加锁的情况：对于第二种同步容器(Collections内部类)来说，假设线程A修改了modCount的值，但是没有同步到线程B，那么线程B遍历就不会发生异常（但实际上问题已经存在了，只是暂时没有出现）
2.  依赖线程执行顺序的情况：对于所有的同步容器来说，假设线程B已经遍历完了容器，此时线程A才开始遍历修改，那么也不会发生异常

代码就不贴了，大家感兴趣的可以直接写几个线程遍历试试，多运行几次，应该就可以看到效果。

> 根据阿里巴巴的开发规范：不要在 foreach 循环里进行元素的 remove/add 操作。remove 元素请使用 Iterator方式，如果并发操作，需要对 Iterator 对象加锁。

这里解释下，关于List.remove和Iterator.remove的区别

*  Iterator.remove：会同步修改expectedModCount=modCount
 *  list.remove：只会修改modCount，因为expectedModCount属于iterator对象的属性，不属于list的属性（但是也可以间接访问）

**源码**：ArrayList.remove移除元素操作

public E remove(int index) { 
            rangeCheck(index);
    				// 1. 这里修改了 modCount
            modCount++;
            E oldValue = elementData(index);
    
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);
            elementData[--size] = null; // clear to let GC do its work
    
            return oldValue;
        }

**源码**：ArrayList.Itr.remove迭代器移除元素操作

public void remove() { 
                if (lastRet < 0)
                    throw new IllegalStateException();
                checkForComodification();
    
                try { 
                  	// 1. 这里调用上面介绍的list.romove，修改modCount
                    ArrayList.this.remove(lastRet);
                    cursor = lastRet;
                    lastRet = -1;
                  	// 2. 这里再同步更新 expectedModCount
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) { 
                    throw new ConcurrentModificationException();
                }
            }

由于同步容器的这些缺点，于是就有了并发容器（下期来介绍）

### 4. 同步容器的使用场景 ###

多用在并发编程，但是并发量又不是很大的场景，比如一些简单的个人博客系统（具体多少并发量算大，这个也是分很多情况而论的，并不是说每秒处理超过多少个请求，就说是高并发，还要结合吞吐量、系统响应时间等多个因素一起考虑）

具体点来说的话，有以下几个场景：

*  写多读少，这个时候同步容器和并发容器的性能差别不大（并发容器可以并发读）
 *  自定义的复合操作，比如getLast等操作（putIfAbsent就算了，因为并发容器有默认提供这个复合操作）
 *  …等等

# 总结 #

1.  什么是同步容器：就是把容器类同步化，这样我们在并发中使用容器时，就不用手动同步，因为内部已经自动同步了
2.  为什么要有同步容器：因为普通的容器类（比如ArrayList)是线程不安全的，如果是在并发中使用，我们就需要手动对其加锁才会安全，这样的话就很太麻烦；所以就有了同步容器，它来帮我们自动加锁
3.  同步容器的优缺点：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xpX0ppYW5fSHVpXw_size_16_color_FFFFFF_t_70 1]

1.  同步容器的使用场景：多用在并发量不是很大的场景，比如个人博客、后台系统等，具体点来说，有以下几个场景：

*  写多读少：这个时候同步容器和并发容器差别不是很大
 *  自定义复合操作：比如getLast等复合操作，因为同步容器都是单个操作进行上锁的，所以可以很方便地去拼接复合操作（记得外部加锁）
 *  …等等

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xpX0ppYW5fSHVpXw_size_16_color_FFFFFF_t_70]: /images/20221014/f452b02d2ddd4fa69079ab78e9b3bbf3.png
[20210530140024412.png]: /images/20221014/2e772b9eaa6d4322bd6485e511a7a476.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xpX0ppYW5fSHVpXw_size_16_color_FFFFFF_t_70 1]: /images/20221014/bab0f7dfa67e45ac918e6e8fe6947759.png