如何保证线程安全有序性_List下如何保证线程安全

之前在看一些模拟面试的视频时，面试官问到：“List如何保证线程安全“。

我脑海中首先想到的是使用List接口下的Vector集合。

然后面试者也同样简单的说出使用Vector集合。

但是面试官显然对这个回答并不满意。

那么List应该如何保证线程安全呢？

这个问题其实可以从《深入理解Java虚拟机》这本书中找到答案

绝对线程安全

绝对的线程安全能够完全满足Brian Goetz给出的线程安全的定义，这个定义其实是很严格的，一 个类要达到“不管运行时环境如何，调用者都不需要任何额外的同步措施”可能需要付出非常高昂的， 甚至不切实际的代价。在Java API中标注自己是线程安全的类，大多数都不是绝对的线程安全。我们 可以通过Java API中一个不是“绝对线程安全”的“线程安全类型”来看看这个语境里的“绝对”究竟是什么 意思。

如果说java.util.Vector是一个线程安全的容器，相信所有的Java程序员对此都不会有异议，因为它 的add()、get()和size()等方法都是被synchronized修饰的，尽管这样效率不高，但保证了具备原子性、 可见性和有序性。不过，即使它所有的方法都被修饰成synchronized，也不意味着调用它的时候就永远 都不再需要同步手段了，请看看代码清单13-2中的测试代码。

对Vector线程安全的测试

private static Vector vector = new Vector();

public static void main(String[] args) {

while (true) {

for (int i = 0; i < 10; i++) {

vector.add(i);

}

Thread removeThread = new Thread(new Runnable() {

@Override

public void run() {

for (int i = 0; i < vector.size(); i++) {

vector.remove(i);

}

}

});

Thread printThread = new Thread(new Runnable() {

@Override

public void run() {

for (int i = 0; i < vector.size(); i++) {

System.out.println((vector.get(i)));

}

}

});

removeThread.start();

printThread.start();

while (Thread.activeCount() > 20) ;

}

}

运行结果如下：

Exception in thread "Thread-45907" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 17

at java.base/java.util.Vector.get(Vector.java:780)

at com.sleep.Demo01$2.run(Demo01.java:27)

at java.base/java.lang.Thread.run(Thread.java:834)

很明显，尽管这里使用到的Vector的get()、remove()和size()方法都是同步的，但是在多线程的环境 中，如果不在方法调用端做额外的同步措施，使用这段代码仍然是不安全的。因为如果另一个线程恰 好在错误的时间里删除了一个元素，导致序号i已经不再可用，再用i访问数组就会抛出一个 ArrayIndexOutOfBoundsException异常。如果要保证这段代码能正确执行下去，我们不得不把 removeThread和printThread的定义改成代码所示的这样。

必须加入同步保证Vector访问的线程安全性

private static Vector vector = new Vector();

public static void main(String[] args) {

while (true) {

for (int i = 0; i < 10; i++) {

vector.add(i);

}

Thread removeThread = new Thread(new Runnable() {

@Override

public void run() {

synchronized (vector) {

for (int i = 0; i < vector.size(); i++) {

vector.remove(i);

}

}

}

});

Thread printThread = new Thread(new Runnable() {

@Override

public void run() {

synchronized (vector) {

for (int i = 0; i < vector.size(); i++) {

System.out.println((vector.get(i)));

}

}

}

});

removeThread.start();

printThread.start();

while (Thread.activeCount() > 20) ;

}

}

假如Vector一定要做到绝对的线程安全，那就必须在它内部维护一组一致性的快照访问才行，每次 对其中元素进行改动都要产生新的快照，这样要付出的时间和空间成本都是非常大的。

相对线程安全

相对线程安全就是我们通常意义上所讲的线程安全，它需要保证对这个对象单次的操作是线程安 全的，我们在调用的时候不需要进行额外的保障措施，但是对于一些特定顺序的连续调用，就可能需 要在调用端使用额外的同步手段来保证调用的正确性。

CopyOnWriteArrayList

1.CopyOnWriteArrayList(字译名称：写时复制)，它可以看成是线程安全且读操作无锁的ArrayList。

2.使用场景：

读操作远远大于写操作，比如有些系统级别的信息，往往需要加载或者修改很少的次数，但是会被系统内的所有模块频繁的访问。

3.原理：

CopyOnWriteArrayList容器允许并发读，读操作时无锁的，性能高。写操作，比如向容器中添加一个元素，则首先将当前容器复制一份，然后在新的副本上执行写操作(此时仍然可以读取，读取的时旧的容器中的数据)，结束之后再将原容器的引用指向新容器。

特点：这种链表，读取完全不用加锁，写入也不会阻塞读取，只有写入和写入之间需要进行同步等待。

缺点：1)占用内存，每次执行写操作都要将原容器拷贝一份，数据量大时，对内存压力较大，可能会引起频繁GC

2)无法保证实时性，Vector对于读写操作都同步，保证了读和写的一致性，但是CopyOnWriteArrayList，写和读分别作用在新老不同的容器上，在写的过程中，读不会阻塞，但是读取到的是老容器的数据。

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

}

}

关于Collections.synchronizedList(List list)

CopyOnWriteArrayList和Collections.synchronizedList是实现线程安全的列表的两种方式。两种实现方式分别针对不同情况有不同的性能表现，其中CopyOnWriteArrayList的写操作性能较差，而多线程的读操作性能较好。而Collections.synchronizedList的写操作性能比CopyOnWriteArrayList在多线程操作的情况下要好很多，而读操作因为是采用了synchronized关键字的方式，其读操作性能并不如CopyOnWriteArrayList。因此在不同的应用场景下，应该选择不同的多线程安全实现类。

public boolean equals(Object o) {

if (this == o)

return true;

synchronized (mutex) {return list.equals(o);}

}

public int hashCode() {

synchronized (mutex) {return list.hashCode();}

}

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

}

public int indexOf(Object o) {

synchronized (mutex) {return list.indexOf(o);}

}

public int lastIndexOf(Object o) {

synchronized (mutex) {return list.lastIndexOf(o);}

}

public boolean addAll(int index, Collection extends E> c) {

synchronized (mutex) {return list.addAll(index, c);}

}

public ListIterator listIterator() {

return list.listIterator(); // Must be manually synched by user

}

public ListIterator listIterator(int index) {

return list.listIterator(index); // Must be manually synched by user

}