对于JDK中的线程安全集合类，个人用的一般是map和队列相关的用的比较多，线程安全的List很少会接触到。开发的时候突然遇到别人问我说有没有线程安全的List…一脸懵逼，所以决定网上找找看有没有相关的结构，别说，还真找到了：

Collections.synchronizedList与CopyOnWriteArrayList

本人之前写的话都是用一个锁来锁定的，今天就来看下这两种结构是不是会比自己用锁会更好。

调试代码如下：

public static void main(String[] args) {
    List l1 = new CopyOnWriteArrayList<>();
    l1.add("1");

    List l2 = new ArrayList<>();
    List l3 = Collections.synchronizedList(l2);
    l3.add("a");
}

先看Collections.synchronizedList：

其实就是内部给你synchronize加了个锁…没啥好看的，不过感觉可以简化下你的代码，至少这个里面的方法全部都是加了锁的。

而且锁的是一个变量，所以锁的粒度小。

再看CopyOnWriteArrayList：

当数组有变化时重新建立一个新的数组

一看这个add()就觉得在性能方面肯定不太靠谱：

第一个原因是使用的是Lock，之前分析ReentrantLock的时候说过，虽然它比synchronize提供了更丰富的功能，但是由于它是API级别的，JVM不会对这个锁进行优化，而synchronize之前分析过，它的锁是一步步升级上来的。

第二个原因是它每增加一个元素都要copy一遍旧数组中的元素，生成一个新数组。

好了…接下来的我就不用看了，我觉得一般情况下，前面那个用的会比较多，后面这个的场景我暂时没碰到。

怎么实现安全的List， 安全， 其实就是线程安全，  List其实是一个集合接口Collection的子接口，  表示的是 集合元素可以重复，并且有序，  

当然接口List也有自己的实现类， 包括：

  Linked List (双向循环链表)、

   ArrayList(可变数组+操作)、

   还有就是 Vector（底层也是数组实现的），

当然如果说安全 ，那么安全和性能是成反比的，   往往安全些的，效率就会降低点，   

Vector 就是线程安全的  但是效率没有 ArrayList的效率高.

如果想让ArrayList也是线程安全的，我们可以调用ArrayList 相关方法时添加线程锁，当然也可以使用集合的工具类Collections.synchronizedList()这个方法处理下， 就相当于Vector一样安全了

大部分人会脱口而出：用Vector，这样只会让面试官鄙视！除了Vector，你还会别的吗？

你至少还得说得上这种：

java.util.Collections.SynchronizedList

它能把所有 List 接口的实现类转换成线程安全的List，比 Vector 有更好的扩展性和兼容性，SynchronizedList的构造方法如下：

final List list;

SynchronizedList(List list) {
    super(list);
    this.list = list;
}

SynchronizedList的部分方法源码如下：

public E get(int index) {
    synchronized (mutex) {return list.get(index);}
}
public E set(int index, E element) {
    synchronized (mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
    synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
    synchronized (mutex) {return list.remove(index);}
}

很可惜，它所有方法都是带同步对象锁的，和 Vector 一样，它不是性能最优的。即使你能说到这里，面试官还会继续往下追问，比如在读多写少的情况，SynchronizedList这种集合性能非常差，还有没有更合适的方案？

介绍两个并发包里面的并发集合类：

java.util.concurrent.CopyOnWriteArrayList
java.util.concurrent.CopyOnWriteArraySet

CopyOnWrite集合类也就这两个，Java 1.5 开始加入，你要能说得上这两个才能让面试官信服。

CopyOnWriteArrayList

CopyOnWrite（简称：COW）：即复制再写入，就是在添加元素的时候，先把原 List 列表复制一份，再添加新的元素。

先来看下它的 add 方法源码：

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();
    }
}

添加元素时，先加锁，再进行复制替换操作，最后再释放锁。

再来看下它的 get 方法源码：

private E get(Object[] a, int index) {
    return (E) a[index];
}

public E get(int index) {
    return get(getArray(), index);
}

可以看到，获取元素并没有加锁。

这样做的好处是，在高并发情况下，读取元素时就不用加锁，写数据时才加锁，大大提升了读取性能。

一：使用synchronized关键字

二：使用Collections.synchronizedList

List集合相信大家都经常用吧，但是可惜的是它不是线程安全的，那么，该如何把list变成一个线程安全的集合呢?下面就来看看吧。

首先我们知道，ArrayList不是一个线程安全的集合，因此在实现多线程开发时，我们不能够使用多个线程同时操作List。如果我们让一个线程向 ArrayList中添加元素，又让另一个线程从其中删除元素，就会出现线程安全问题，抛出ConcurrentModificationException异常。

Vector

我们要知道Vector，这是一个可变长度的数组，它类似于ArrayList，但与ArrayList不同，Vector是绝对线程安全的，它的机制就是会给几乎所有的public方法都加上synchronized关键字。但是，由于加锁会导致性能降低到一定程度，在不需要并发访问同一对象时，像这样强制性的同步机制就显得非常多余了，所以Vector现在已经被抛弃啦。

Collections

但是办法总是想出来的，在Vector和HashTable相继被弃用后，它们被ArrayList及HashMap代替，但ArrayList及HashMap它们不是线程安全的，所以java中就有了Collections这么一个工具类，它能够提供相应的包装方法把ArrayList和HashMap包装成线程安全的集合。

主要有两种方式：

一：使用synchronized关键字，这个大家应该都很熟悉了，不解释了；
二：使用Collections.synchronizedList();使用方法如下：
       假如你创建的代码如下：List

使用Vertor即可

Java的List如何实现线程安全？

Collections.synchronizedList(names);效率最高，线程安全

Java的List是我们平时很常用的集合，线程安全对于高并发的场景也十分的重要，那么List如何才能实现线程安全呢 ？

加锁

首先大家会想到用Vector，这里我们就不讨论了，首先讨论的是加锁，例如下面的代码

public class Synchronized{

    private List  names = new LinkedList<>();
    
    public synchronized void addName(String name ){
        names.add("abc");
    }
    public String getName(Integer index){
        Lock lock =new ReentrantLock();
        lock.lock();
        try {
            return names.get(index);
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
        return null;
    }
}

synchronized一加，或者使用lock 可以实现线程安全，但是这样的List要是很多个，代码量会大大增加。

java自带类

在java中我找到自带有两种方法

CopyOnWriteArrayList

CopyOnWrite 写入时复制，它使一个List同步的替代品，通常情况下提供了更好的并发性，并且避免了再迭代时候对容器的加锁和复制。通常更适合用于迭代，在多插入的情况下由于多次的复制性能会一定的下降。

下面是add方法的源代码

    public boolean add(E e) {
        final ReentrantLock lock = this.lock; // 加锁 只允许获得锁的线程访问
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            // 创建个长度加1的数组并复制过去
            Object[] newElements = Arrays.copyOf(elements, len + 1); 
            newElements[len] = e; // 赋值
            setArray(newElements); // 设置内部的数组
            return true;
        } finally {
            lock.unlock();
        }
    }

Collections.synchronizedList

Collections中有许多这个系列的方法例如

主要是利用了装饰者模式对传入的集合进行调用 Collotions中有内部类SynchronizedList

   static class SynchronizedList
        extends SynchronizedCollection
        implements List {
        private static final long serialVersionUID = -7754090372962971524L;

        final List list;

        SynchronizedList(List list) {
            super(list);
            this.list = list;
        }
        public E get(int index) {
            synchronized (mutex) {return list.get(index);}
        }
        public E set(int index, E element) {
            synchronized (mutex) {return list.set(index, element);}
        }
        public void add(int index, E element) {
            synchronized (mutex) {list.add(index, element);}
        }
        public E remove(int index) {
            synchronized (mutex) {return list.remove(index);}
        }
        
    static class SynchronizedCollection implements Collection, Serializable {
        private static final long serialVersionUID = 3053995032091335093L;

        final Collection c;  // Backing Collection
        final Object mutex;     // Object on which to synchronize

这里上面的mutex就是锁的对象 在构建时候可以指定锁的对象 主要使用synchronize关键字实现线程安全

    /**
     * @serial include
     */
    static class SynchronizedList
        extends SynchronizedCollection
        implements List {
        private static final long serialVersionUID = -7754090372962971524L;

        final List list;

        SynchronizedList(List list) {
            super(list);
            this.list = list;
        }
        SynchronizedList(List list, Object mutex) {
            super(list, mutex);
            this.list = list;
        }
这里只是列举SynchronizedList ，其他类类似，可以看下源码了解下。

测试
public class Main {
    public static void main(String[] args) {
        List names = new LinkedList<>();
        names.add("sub");
        names.add("jobs");
        // 同步方法1 内部使用lock
        long a = System.currentTimeMillis();
        List strings = new CopyOnWriteArrayList<>(names);
        for (int i = 0; i < 100000; i++) {
            strings.add("param1");
        }
        long b = System.currentTimeMillis();
        // 同步方法2 装饰器模式使用 synchronized
        List synchronizedList = Collections.synchronizedList(names);
        for (int i = 0; i < 100000; i++) {
            synchronizedList.add("param2");
        }
        long c = System.currentTimeMillis();
        System.out.println("CopyOnWriteArrayList time == "+(b-a));
        System.out.println("Collections.synchronizedList time == "+(c-b));
    }
}

两者内部使用的方法都不一样，CopyOnWriteArrayList内部是使用lock进行加锁解锁完成单线程访问，synchronizedList使用的是synchronize

进行了100000次添加后时间对比如下：