ArrayList

首先手写一个案例来证明ArrayList不安全。

image-20200925090209333

运行多次查看结果～

image-20200925090300603

打印结果与我们的预期不符，list集合中添加了null。

将线程数量添加至30个

image-20200925090448884

运行报java.util.ConcurrentModificationException并发修改异常

image-20200925090702077

至此我们可以发现ArrayList是多线程下的不安全的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class ContainerNotSafeDemo {
    
    public static void main(String[] args) {

        //java.util.ConcurrentModificationException
        //new Vector<>();
        //Collections.synchronizedList(new ArrayList<>());
        //new CopyOnWriteArrayList<>();
        List<String> list = new ArrayList<>();

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

Vector

在我们学集合的时候，就已经知道该类是多线程安全的。使用它来进行测试

image-20200925090959566

运行结果，发现未发现报错。说明该类是在多线程下安全的。

image-20200925091018398

为啥Vector在多线程下安全呢？我们可以查看源码

image-20200925091207582

发现该类的add等方法是加了synchronized关键字的，是同步方法～虽然该类能保证多线程下的安全。但不推荐使用，存在性能问题！

而且我们查看源码可以得知，Vector是jdk1.0就存在的。

image-20200925091456098

而ArrayList是jdk1.2才开始的。

image-20200925091556661

也就是官方在推出一个多线程下安全的list集合类后，特地推出一个不安全的ArrayList类？这是让人难以理解的，除非他能够比Vector做的跟好！

SynchronizedList

我们可以通过Collections.synchronizedList将ArrayList转换成一个线程安全的SynchronizedList。

image-20200925092527419

image-20200925092541633

查看源码发现

image-20200925092739528

与Vector使用同步方法不同，SynchronizedList底层使用同步代码块来保证线程安全。

SynchronizedList和Vector最主要的区别：

  1. SynchronizedList有很好的扩展和兼容功能。他可以将所有的List的子类转成线程安全的类。

  2. 使用SynchronizedList的时候，进行遍历时要手动进行同步处理。

  3. SynchronizedList可以指定锁定的对象。

CopyOnWriteArrayList

前两个方法跟我们JUC是没有关系的，既然是JUC我们可以使用JUC包下的CopyOnWriteArrayList类

image-20200925093418203

image-20200925093451079

运行测试，结果正常

image-20200925093528110

查看CopyOnWriteArrayList源码

image-20200925093936658

Object型数组array存放数据，并且发现array这个Object数组是用volatile关键字修饰的，保持可见性（后面文章会写）

查看add方法

image-20200925094123145

底层是用来ReentrantLock锁来保持多线程同步的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public boolean add(E e) {
    //1、先加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        //2、拷贝数组
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        //3、将元素加入到新数组中
        newElements[len] = e;
        //4、将array引用指向到新数组
        setArray(newElements);
        return true;
    } finally {
       //5、解锁
        lock.unlock();
    }
}

该源码解析

  • 首先使用ReentrantLock锁保证该操作是多线程下安全的。
  • Object[] elements = getArray();获取到当前类中的Object型数组array
  • int len = elements.length;Object[] newElements = Arrays.copyOf(elements, len + 1);并且获取到原来存储元素数组的长度。利用Arrays.copyOf方法将数组复制为newElements，并且长度+1。
  • newElements[len] = e;接着将添加到元素添加到数据末尾处
  • setArray(newElements);设置newElements为当前类的array。
  • retrun true添加成功返回true

image-20200925095452798

CopyOnWriteArrayList使用了一种叫写时复制的方法，当有新元素添加到CopyOnWriteArrayList时，先从原有的数组中拷贝一份出来，然后在新的数组做写操作，写完之后，再将原来的数组引用指向到新数组。

当有新元素加入的时候，如下图，创建新数组，并往新数组中加入一个新元素,这个时候，array这个引用仍然是指向原数组的。

image-20200925100240888

CopyOnWriteArrayList的整个add操作都是在锁的保护下进行的。
这样做是为了避免在多线程并发add的时候，复制出多个副本出来,把数据搞乱了，导致最终的数组数据不是我们期望的。

由于所有的写操作都是在新数组进行的，这个时候如果有线程并发的写，则通过锁来控制，如果有线程并发的读，则分几种情况：
1、如果写操作未完成，那么直接读取原数组的数据；
2、如果写操作完成，但是引用还未指向新数组，那么也是读取原数组数据；
3、如果写操作完成，并且引用已经指向了新的数组，那么直接从新数组中读取数据。

可见，CopyOnWriteArrayList的读操作是可以不用加锁的

通过上面的分析，CopyOnWriteArrayList 有几个缺点：

  1. 由于写操作的时候，需要拷贝数组，会消耗内存，如果原数组的内容比较多的情况下，可能导致young gc或者full gc

  2. 不能用于实时读的场景，像拷贝数组、新增元素都需要时间，所以调用一个set操作后，读取到数据可能还是旧的,虽然CopyOnWriteArrayList 能做到最终一致性,但是还是没法满足实时性要求；

CopyOnWriteArrayList 合适读多写少的场景，不过这类慎用
因为谁也没法保证CopyOnWriteArrayList 到底要放置多少数据，万一数据稍微有点多，每次add/set都要重新复制数组，这个代价实在太高昂了。在高性能的互联网应用中，这种操作分分钟引起故障。

HashSet

image-20200925101221028

多线程下同样出现java.util.ConcurrentModificationException并发修改异常。该类不安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ContainerNotSafeDemo {

    public static void main(String[] args) {

        //java.util.ConcurrentModificationException

        //Collections.synchronizedSet(new HashSet<>());
        //new CopyOnWriteArraySet<>();
        Set<String> set = new HashSet<>();

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

}

SynchronizedSet

使用工具类将HashSet转换成SynchronizedSet。Collections.synchronizedSet(new HashSet<>());

image-20200925101708262

image-20200925101928030

查看源码该类继承SynchronizedCollection

image-20200925102031681

SynchronizedCollection中的添加删除方法也都是使用了同步代码块，来保证线程安全。

image-20200925102143512

CopyOnWriteArraySet

同样JUC包下提供了CopyOnWriteArraySet

image-20200925102334413

image-20200925102508678

查看CopyOnWriteArraySet的源码

image-20200925102555087

发现其底层使用的还是CopyOnWriteArrayList。。其操作都是借用来CopyOnWriteArrayList来实现的。

image-20200925102907362

HashMap

image-20200925103227594

多线程下同样出现java.util.ConcurrentModificationException并发修改异常。该类不安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ContainerNotSafeDemo {

    public static void main(String[] args) {

        //java.util.ConcurrentModificationException

        // Collections.synchronizedMap(new HashMap<>());
        // new ConcurrentHashMap<>();
        Map<String,String> map = new HashMap<>();

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

}

SynchronizedMap

使用工具类将HashMapt转换成SynchronizedMap。Collections.synchronizedMap(new HashMap<>());

image-20200925103618341

image-20200925103634918

查看源码，同样适用同步代码快来保证线程安全。

image-20200925103737383

ConcurrentHashMap

同样JUC提供了ConcurrentHashMap

image-20200925103906619

image-20200925103938278

image-20200925103957933