Hi，大家好，我是编程小6，很荣幸遇见你，我把这些年在开发过程中遇到的问题或想法写出来，今天说一说java list 多线程_如何保证arraylist线程安全,希望能够帮助你!!!。

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

加锁

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

public class Synchronized{ 
   

    private List<String>  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<E>
        extends SynchronizedCollection<E>
        implements List<E> { 
   
        private static final long serialVersionUID = -7754090372962971524L;

        final List<E> list;

        SynchronizedList(List<E> 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<E> implements Collection<E>, Serializable { 
   
        private static final long serialVersionUID = 3053995032091335093L;

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

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

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

        final List<E> list;

        SynchronizedList(List<E> list) { 
   
            super(list);
            this.list = list;
        }
        SynchronizedList(List<E> list, Object mutex) { 
   
            super(list, mutex);
            this.list = list;
        }

这里只是列举SynchronizedList ，其他类类似，可以看下源码了解下。

测试

public class Main { 
   
    public static void main(String[] args) { 
   
        List<String> names = new LinkedList<>();
        names.add("sub");
        names.add("jobs");
        // 同步方法1 内部使用lock
        long a = System.currentTimeMillis();
        List<String> strings = new CopyOnWriteArrayList<>(names);
        for (int i = 0; i < 100000; i++) { 
   
            strings.add("param1");
        }
        long b = System.currentTimeMillis();
        // 同步方法2 装饰器模式使用 synchronized
        List<String> 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次添加后时间对比如下：

可以看出来还是使用了synchronize的集合工具类在添加方面更加快一些，其他方法这里篇幅关系就不测试了，大家有兴趣去试一下。

今天的分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。