Java——多线程高并发系列之ArrayListHashSetHashMap集合线程不安全的解决方案

Posted 张起灵-小哥

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java——多线程高并发系列之ArrayListHashSetHashMap集合线程不安全的解决方案相关的知识,希望对你有一定的参考价值。

1.ArrayList的线程不安全解决方案

将main方法的第一行注释打开,多执行几次,会看到如下图这样的异常信息:👇👇👇

这是一个 并发修改 异常,首先ArrayList肯定是线程不安全的,产生这个异常的原因就是可能第一个线程刚进入 ArrayList 集合中要进行 add 操作时,另外一个线程此时也进来进行 add 操作,而第三个线程又进来进行 get 操作,导致读写没办法进行同步了,最终打印结果的时候就炸了。

解决方案看代码中的剩下几行注释。

package test.notsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 演示ArrayList的线程不安全问题及解决方案
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        //List<String> list = new ArrayList<>();

        //解决方法1:使用Vector
        //List<String> list = new Vector<>();

        //解决方法2:Collections
        //List<String> list = Collections.synchronizedList(new ArrayList<>());

        //解决方法3:CopyOnWriteArrayList
        List<String> list = new CopyOnWriteArrayList<>();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

关于 CopyOnWriteArrayList 解决线程不安全问题的简单解释:就看源码中的 add(E e) 这个方法:

    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

这个 CopyOnWriteArrayList 在进行 add 添加操作之前,先进行 lock 上锁,然后通过 getArray() 获取到原 ArrayList 集合容器,之后调用 Arrays.copyOf 方法将原容器拷贝出一个新容器,因为要添加(长度自然也要 +1),之后向这个新容器中添加元素,添加完成之后,调用 setArray 方法将原容器的引用指向了这个新的容器。     那么这样做的好处就是:添加元素在新容器中,原容器该是啥样还是啥样,其他线程要get读取元素就还从原容器中读(即多个线程可以进行并发读);而其他线程要 add 添加,要等待其他线程完成之后,将原容器的引用指向新容器就可以了。

CopyOnWrite 容器在面对读和写的时候是两个不同的容器,也是用到了读写分离的思想。


2.HashSet的线程不安全解决方案

这里如果是 new HashSet 了话,仍然可能出现向上面 ArrayList 一样的 并发修改异常。解决方案看代码中的注释。

package test.notsafe;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * 演示HashSet的线程不安全问题及解决方案
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        //Set<String> set = new HashSet<>();

        //解决方法1:Collections
        //Set<String> set = Collections.synchronizedSet(new HashSet<>());

        //解决方法2:CopyOnWriteArraySet
        Set<String> set = new CopyOnWriteArraySet<>();

        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0,8));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

3.HashMap的线程不安全解决方案 

package test.notsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 演示HashMap的线程不安全问题及解决方案
 */
public class ThreadDemo4 {
    public static void main(String[] args) {
        //Map<String,Object> map = new HashMap<>();

        //解决方法1:Collections
        //Map<String,Object> map = Collections.synchronizedMap(new HashMap<>());

        //解决方法2:ConcurrentHashMap
        Map<String,Object> map = new ConcurrentHashMap<>();

        for (int i = 0; i < 10; i++) {
            String key = String.valueOf(i);
            new Thread(() -> {
                map.put(key,UUID.randomUUID().toString().substring(0,8));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

以上是关于Java——多线程高并发系列之ArrayListHashSetHashMap集合线程不安全的解决方案的主要内容,如果未能解决你的问题,请参考以下文章

Java——多线程高并发系列之线程池(Executor)的理解与使用

Java——多线程高并发系列之线程池(Executor)的理解与使用

Java——多线程高并发系列之ThreadLocal的使用

Java——多线程高并发系列之ThreadLocal的使用

Java——多线程高并发系列之LockReentrantLock

Java——多线程高并发系列之LockReentrantLock