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

Posted 2023-03-14

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

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

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的集合工具类在添加方面更加快一些，其他方法这里篇幅关系就不测试了，大家有兴趣去试一下。

参考技术A Java的List如何实现线程安全？
Collections.synchronizedList(names);效率最高，线程安全
Java的List是我们平时很常用的集合，线程安全对于高并发的场景也十分的重要，那么List如何才能实现线程安全呢 ？加锁
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同步的替代品，通常情况下提供了更好的并发性，并且避免了再迭代时候对容器的加锁和复制。通常更适合用于迭代，在多插入的情况下由于多次的复制性能会一定的下降。 参考技术B List集合相信大家都经常用吧，但是可惜的是它不是线程安全的，那么，该如何把list变成一个线程安全的集合呢?下面就来看看吧。

首先我们知道，ArrayList不是一个线程安全的集合，因此在实现多线程开发时，我们不能够使用多个线程同时操作List。如果我们让一个线程向

ArrayList中添加元素，又让另一个线程从其中删除元素，就会出现线程安全问题，抛出ConcurrentModificationException异常。