如何创建线程安全的list？

一：使用synchronized关键字

二：使用Collections.synchronizedList()

一、 ArrayList概述：

ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。

ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。

 ArrayList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问，实现了Cloneable接口，能被克隆。

每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元素，其容量也自动增长。自动增长会带来数据向新数组的重新拷贝，因此，如果可预知数据量的多少，可在构造ArrayList时指定其容量。

在添加大量元素前，应用程序也可以使用ensureCapacity *** 作来增加ArrayList实例的容量，这可以减少递增式再分配的数量。 

注意，此实现不是同步的。如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。

使用synchronized关键字同步方法就可以了。

public class Foo2 {

private int x = 100

public int getX() {

return x

}

//同步方法

public synchronized int fix(int y) {

x = x - y

System.out.println("线程"+Thread.currentThread().getName() + "运行结束，减少“" + y + "”，当前值为：" + x)

return x

}

}

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 = 0i <100000i++) {

strings.add("param1")

}

long b = System.currentTimeMillis()

// 同步方法2 装饰器模式使用 synchronized

List<String>synchronizedList = Collections.synchronizedList(names)

for (int i = 0i <100000i++) {

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

---