转载自  出场率比较高的一道多线程安全面试题

下面这个问题是 Java 程序员面试经常会遇到的吧。

工作一两年的应该都知道 ArrayList 是线程不安全的，要使用线程安全的就使用 Vector，这也是各种 Java 面试宝典里面所提及的，可能很多工作好几年的程序员都停留在这个知识面上。

先说说为什么 ArrayList 是线程不安全的吧，来看以下的代码。

1. /**

2. * 微信公众号：Java技术栈

3. */

4. public class TestArrayList {

5.  

6.    private static List<Integer> list = new ArrayList<>();

7.  

8.    public static void main(String[] args) throws InterruptedException {

9.        for (int i = 0; i < 10; i++) {

10.            testList();

11.            list.clear();

12.        }

13.    }

14.  

15.    private static void testList() throws InterruptedException {

16.        Runnable runnable = () -> {

17.            for (int i = 0; i < 10000; i++) {

18.                list.add(i);

19.            }

20.        };

21.  

22.        Thread t1 = new Thread(runnable);

23.        Thread t2 = new Thread(runnable);

24.        Thread t3 = new Thread(runnable);

25.  

26.        t1.start();

27.        t2.start();

28.        t3.start();

29.  

30.        t1.join();

31.        t2.join();

32.        t3.join();

33.  

34.        System.out.println(list.size());

35.    }

36.  

37. }

这是它的输出结果，我们期望的结果应该都是：30000，然后并不是，这就是传说中的多线程并发问题了。

1. Exception in thread "Thread-1" java.lang.ArrayIndexOutOfBoundsException: 15786

2.    at java.base/java.util.ArrayList.add(ArrayList.java:468)

3.    at java.base/java.util.ArrayList.add(ArrayList.java:480)

4.    at com.test.thread.TestArrayList.lambda$testList$0(TestArrayList.java:23)

5.    at java.base/java.lang.Thread.run(Thread.java:844)

6. 20332

7. 16100

8. 14941

9. 23749

10. 15631

11. 22118

12. 27417

13. 30000

14. 28691

15. 27843

现象分析

从以上结果可以总结出 ArrayList 在并发情况下会出现的几种现象。

1、发生 ArrayIndexOutOfBoundsException 异常；

1. private void add(E e, Object[] elementData, int s) {

2.    if (s == elementData.length)

3.        elementData = grow();

4.    elementData[s] = e;

5.    size = s + 1;

6. }

定位到异常所在源代码，毫无疑问，问题是出现在多线程并发访问下，由于没有同步锁的保护，造成了 ArrayList 扩容不一致的问题。

2、程序正常运行，输出了少于实际容量的大小；

这个也是多线程并发赋值时，对同一个数组索引位置进行了赋值，所以出现少于预期大小的情况。

3、程序正常运行，输出了预期容量的大小；

这是正常运行结果，未发生多线程安全问题，但这是不确定性的，不是每次都会达到正常预期的。

解决方案

既然这样，那么在高并发情况下，使用什么样的列表集合保护线程安全呢？回到文章最开始的地方，使用 Vector，还有别的吗？当然有，篇幅有限，请各位看官期待后续文章。

另外，像 HashMap, HashSet 等都有类似多线程安全问题，在多线程并发环境下避免使用这种集合。