JUC系列(四) | 集合的线程安全问题

2022-10-31 14:59:52 浏览数 (1)

多线程一直Java开发中的难点，也是面试中的常客，趁着还有时间，打算巩固一下JUC方面知识，我想机会随处可见，但始终都是留给有准备的人的，希望我们都能加油！！！ 沉下去，再浮上来，我想我们会变的不一样的。 JUC 系列

  • JUC系列（一）什么是JUC？
  • JUC系列（二）回顾Synchronized关键字 正在持续更新中…

喜欢这样的天，暗暗的，又带着光

一、引入

我想我们大家肯定都使用过ArrayList的吧。不知道你之前有没有想过它也会牵扯到线程安全问题勒。

一、问题引入：

我们一起先看看下面的程序吧，看你能看出什么问题吗？

代码语言：javascript复制
public static void main(String[] args) {
    List list = new ArrayList();
    for (int i = 0; i < 20; i  ) {
        new Thread(() -> {
            list.add(UUID.randomUUID().toString());
            System.out.println(list);
        }, "线程"   i).start();
    }
}

你觉得能每次都能正常输出吗？

答案是否定的，也许好几次运行程序都不会出错，但是偶尔就会遇上一次的。会报一个ConcurrentModificationException的异常，中文名为：并发修改异常。

原因：就是我们正在读的时候，正好也遇上了写操作，我们这里又没有同步代码块、锁什么的，那么此时肯定是不可以继续往下执行的。

还有ArrayList的add方法并非线程同步的。(jdk11源码)

代码语言：javascript复制
public boolean add(E e) {
    modCount  ;
    add(e, elementData, size);
    return true;
}

我们该如何解决这个问题呢？？？

二、解决方式

第一种方式：使用 Vector

我们可以使用Vector来代替ArrayList，因为Vector 继承了 AbstractList 类并且实现了List 、RandmoAccess 接口。

RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。在 Vector 中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访 问。

代码语言：javascript复制
public class Vector<E> extends AbstractList<E> implements List<E> ,RandomAccess

我们将上面的程序修改后，程序将不再出现异常。

代码语言：javascript复制
public static void main(String[] args) {
    List list = new Vector();
    for (int i = 0; i < 20; i  ) {
        new Thread(() -> {
            list.add(UUID.randomUUID().toString());
            System.out.println(list);
        }, "线程"   i).start();
    }
}

原因其实就在 Vector 的代码中。

代码语言：javascript复制
public synchronized boolean add(E e) {
    modCount  ;
    add(e, elementData, elementCount);
    return true;
}

add方法上加了synchronized关键字，让这个方法成为了同步方法块。

第二种方式：使用 Collections

Collections 提供了方法 synchronizedList 保证 list 是同步线程安全的。

Collections 仅包含对集合进行操作或返回集合的静态方法，所以我们通常也称Collections 为集合的工具类。

代码语言：javascript复制
public static void main(String[] args) {
    List list = Collections.synchronizedList(new ArrayList<>());
    for (int i = 0; i < 20; i  ) {
        new Thread(() -> {
            list.add(UUID.randomUUID().toString());
            System.out.println(list);
        }, "线程"   i).start();
    }
}

这样也不会发生异常。源码上也都有体现

代码语言：javascript复制
public void add(int index, E element) {
    synchronized (mutex) {list.add(index, element);}
}

大多数方法都提供了同步和不同步两种api。

第三种方式： 使用 CopyOnWriteArrayList

CopyOnWriteArrayList和ArrayList 一样，它是个可变数组。

有以下几个特点：

  1. 更新操作开销大（add()、set()、remove()等等），因为要复制整个数组
  2. 是线程安全的。
  3. 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多 于可变操作，需要在遍历期间防止线程间的冲突。
  4. 独占锁效率低：采用读写分离思想
  5. 写线程获取到锁，其他写线程阻塞
  6. 复制思想

CopyOnWriteArrayList 的思想和原理：

当我们要添加一个元素的时候，不直接往当前容器中添加，而是应该先将当前容器复制一份，然后在新的容器中进行添加操作，等到添加完成后，我们再让原容器的引用指向新的容器。

当然，这个时候会抛出来一个新的问题，也就是数据不一致的问题。如果写线程还没来得及写进内存，那么其他的线程就会读到了脏数据。

代码语言：javascript复制
public static void main(String[] args) {
    List list = new CopyOnWriteArrayList();
    for (int i = 0; i < 20; i  ) {
        new Thread(() -> {
            list.add(UUID.randomUUID().toString());
            System.out.println(list);
        }, "线程"   i).start();
    }
}

为什么不会产生线程安全问题呢？

我们从"动态数组"和“线程安全”两个方面来看待：

动态数组机制 ：

它内部有个“volatile 数组”(array)来保持数据。在“添加/修改/删除”数据 时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该 数组赋值给“volatile 数组”, 这就是它叫做 CopyOnWriteArrayList 的原因

它在“添加/修改/删除”数据时，都会新建数组，所以涉及到更新的操作，CopyOnWriteArrayList效率都会很低；但如果只是单单进行遍历查找的话， 效率能够达到比较高的。

代码语言：javascript复制
public boolean add(E element) {
    synchronized (lock) {
        checkForComodification();
        CopyOnWriteArrayList.this.add(offset   size, element);
        expectedArray = getArray();
        size  ;
    }
    return true;
}
// CopyOnWriteArrayList.this.add(offset   size, element);
public void add(int index, E element) {
    synchronized (lock) {
        Object[] es = getArray();
        int len = es.length;
        if (index > len || index < 0)
            throw new IndexOutOfBoundsException(outOfBounds(index, len));
        Object[] newElements;
        int numMoved = len - index;
        if (numMoved == 0)
            newElements = Arrays.copyOf(es, len   1);
        else {
            newElements = new Object[len   1];
            System.arraycopy(es, 0, newElements, 0, index);
            System.arraycopy(es, index, newElements, index   1,
                             numMoved);
        }
        newElements[index] = element;
        setArray(newElements);
    }
}

线程安全机制：

通过 volatile 和互斥锁（synchronized）来实现的。

代码语言：javascript复制
/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;

通过“volatile 数组”来保存数据的

  • 一个线程读取 volatile 数组时，总能看 到其它线程对该 volatile 变量最后的写入；就这样，通过 volatile 提供了“读 取到的数据总是最新的”这个机制的保证。

通过互斥锁来保护数据

  • 在“添加/修改/删除”数据时，都会先去“获取互斥锁”， 在修改完毕之后，先将数据更新到“volatile 数组”中，然后再“释放互斥 锁”。

另外补充：

除了ArrayList是线程不安全的，还有HashMap、HashSet都是不安全的。

HashMap、HashSet的解决方式可以用Hashtable解决，当然不局限于这一种哈，（还没看完

编程算法 安全 容器 java hashmap

0 人点赞