list_add线程安全c语言,线程安全的list之synchronizedList和CopyOnWriteArrayList

在上篇文章中我们已经介绍了其他的一些list集合，如ArrayList、linkedlist等。不清楚的可以看下上篇文章https://www.jianshu.com/p/6227ab5b33f7

但是向ArrayList这些会出现线程不安全的问题，我们该怎样解决呢？接下来就是要介绍我们线程安全的list集合synchronizedList和CopyOnWriteArrayList。

一、synchronizedList

synchronizedList的使用方式：

public void test(){

ArrayList list = new ArrayList<>();

List sycList = Collections.synchronizedList(list);

sycList.add("a");

sycList.remove("a");

}

从上面的使用方式中我们可以看出，synchronizedList是将List集合作为参数来创建的synchronizedList集合。

synchronizedList为什么是线程安全的呢？

我们先来看一下他的源码：

@Override

public int size() {

synchronized(mutex) {

return backingList.size();

}

}

@Override

public boolean isEmpty() {

synchronized(mutex) {

return backingList.isEmpty();

}

}

@Override

public Object[] toArray() {

synchronized(mutex) {

return backingList.toArray();

}

}

@Override

public boolean add(T e) {

synchronized(mutex) {

return backingList.add(e);

}

}

@Override

public boolean remove(Object o) {

synchronized(mutex) {

return backingList.remove(o);

}

}

我们大概贴了一些常用方法的源码，从上面的源码中我们可以看出，其实synchronizedList线程安全的原因是因为它几乎在每个方法中都使用了synchronized同步锁。

synchronizedList遍历为什么还需要加锁？

synchronizedList官方文档中给出的使用方式是以下方式：

List list = Collections.synchronizedList(new ArrayList());

...

synchronized (list) {

Iterator i = list.iterator(); // Must be in synchronized block

while (i.hasNext())

foo(i.next());

}

在以上源码中我们可以看出，官方文档是建议我们在遍历的时候加锁处理的。但是既然内部方法以及加了锁，为什么在遍历的时候还需要加锁呢？我们来看一下它的遍历方法：

@Override

public Iterator iterator() {

return backingList.iterator();

}

从以上源码可以看出，虽然内部方法中大部分都已经加了锁，但是iterator方法却没有加锁处理。那么如果我们在遍历的时候不加锁会导致什么问题呢？

试想我们在遍历的时候，不加锁的情况下，如果此时有其他线程对此集合进行add或者remove操作，那么这个时候就会导致数据丢失或者是脏数据的问题，所以如果我们对数据的要求较高，想要避免这方面问题的话，在遍历的时候也需要加锁进行处理。

但是既然是使用synchronized加锁进行处理的，那肯定避免不了一些锁开销。有没有效率更好的方式呢？那就是我们另一个主要的并发集合CopyOnWriteArrayList。

二、CopyOnWriteArrayList

CopyOnWriteArrayList是在执行修改操作时，copy一份新的数组进行相关的操作，在执行完修改操作后将原来集合指向新的集合来完成修改操作。具体源码如下：

/** The array, accessed only via getArray/setArray. */

private volatile transient Object[] array;//保证了线程的可见性

public void add(int index, E element) {

final ReentrantLock lock = this.lock;

lock.lock();

try {

Object[] elements = getArray();

int len = elements.length;

if (index > len || index < 0)

throw new IndexOutOfBoundsException("Index: "+index+

", Size: "+len);

Object[] newElements;

int numMoved = len - index;

if (numMoved == 0)

newElements = Arrays.copyOf(elements, len + 1); //copy一份比当前数组长度+1的array数组

else {

newElements = new Object[len + 1]; //将add的参数赋值

System.arraycopy(elements, 0, newElements, 0, index);

System.arraycopy(elements, index, newElements, index + 1,

numMoved);

}

newElements[index] = element;

setArray(newElements); //将原数组指向新的数组

} finally {

lock.unlock();

}

}

public E remove(int index) {

final ReentrantLock lock = this.lock;

lock.lock();

try {

Object[] elements = getArray();

int len = elements.length;

E oldValue = get(elements, index);

int numMoved = len - index - 1;

if (numMoved == 0)

setArray(Arrays.copyOf(elements, len - 1)); //copy一份比当前数组长度-1的array数组

else {

Object[] newElements = new Object[len - 1];

System.arraycopy(elements, 0, newElements, 0, index);

System.arraycopy(elements, index + 1, newElements, index,

numMoved);

setArray(newElements); //将原数组指向新的数组

}

return oldValue;

} finally {

lock.unlock();

}

}

/**

* 将原数组指向新的数组

*/

final void setArray(Object[] a) {

array = a;

}

从以上源码我们可以看出，它在执行add方法和remove方法的时候，分别创建了一个当前数组长度+1和-1的数组，将数据copy到新数组中，然后执行修改操作。修改完之后调用setArray方法来指向新的数组。在整个过程中是使用ReentrantLock可重入锁来保证不会有多个线程同时copy一个新的数组，从而造成的混乱。并且使用volatile修饰数组来保证修改后的可见性。读写操作互不影响，所以在整个过程中整个效率是非常高的。

总结

synchronizedList适合对数据要求较高的情况，但是因为读写全都加锁，所有效率较低。

CopyOnWriteArrayList效率较高，适合读多写少的场景，因为在读的时候读的是旧集合，所以它的实时性不高。