CopyOnWriteArrayList 与 Collections synchronizedList 的性能对比

public boolean add(E e) {
ensureCapacity(size + 1);  // Increments modCount!!
elementData[size++] = e;//使用了size++操作，会产生多线程数据丢失问题。
return true;
   }

public static <T> List<T> synchronizedList(List<T> list) {
return (list instanceof RandomAccess ?
               new SynchronizedRandomAccessList<T>(list) :
               new SynchronizedList<T>(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 ListIterator<E> listIterator() {
        return list.listIterator(); // Must be manually synched by user 需要用户保证同步，否则仍然可能抛出ConcurrentModificationException
        }

    public ListIterator<E> listIterator(int index) {
        return list.listIterator(index); // Must be manually synched by user <span style="font-family: Arial, Helvetica, sans-serif;">需要用户保证同步，否则仍然可能抛出ConcurrentModificationException</span>
        }

/** The lock protecting all mutators */
    transient final ReentrantLock lock = new ReentrantLock();

    /** The array, accessed only via getArray/setArray. */
    private volatile transient Object[] array;//保证了线程的可见性

     public boolean add(E e) {
    final ReentrantLock lock = this.lock;//ReentrantLock 保证了线程的可见性和顺序性，即保证了多线程安全。
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);//在原先数组基础之上新建长度＋1的数组，并将原先数组当中的内容拷贝到新数组当中。
        newElements[len] = e;//设值
        setArray(newElements);//对新数组进行赋值
        return true;
    } finally {
        lock.unlock();
    }
    }

public E get(int index) {
       return (E)(getArray()[index]);
   }

package com.yang.test;

import org.junit.Test;

import java.util.*;
import java.util.concurrent.*;

/**
 * Created with IntelliJ IDEA.
 * User: yangzl2008
 * Date: 14-9-18
 * Time: 下午8:36
 * To change this template use File | Settings | File Templates.
 */
public class Test02 {

    private int NUM = 10000;
    private int THREAD_COUNT = 16;

    @Test
    public void testAdd() throws Exception {
        List<Integer> list1 = new CopyOnWriteArrayList<Integer>();
        List<Integer> list2 = Collections.synchronizedList(new ArrayList<Integer>());
        Vector<Integer> v  = new Vector<Integer>();

        CountDownLatch add_countDownLatch = new CountDownLatch(THREAD_COUNT);
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);

        int add_copyCostTime = 0;
        int add_synchCostTime = 0;
        for (int i = 0; i < THREAD_COUNT; i++) {
            add_copyCostTime += executor.submit(new AddTestTask(list1, add_countDownLatch)).get();
        }
        System.out.println("CopyOnWriteArrayList add method cost time is " + add_copyCostTime);

        for (int i = 0; i < THREAD_COUNT; i++) {
            add_synchCostTime += executor.submit(new AddTestTask(list2, add_countDownLatch)).get();
        }
        System.out.println("Collections.synchronizedList add method cost time is " + add_synchCostTime);


    }

    @Test
    public void testGet() throws Exception {
        List<Integer> list = initList();

        List<Integer> list1 = new CopyOnWriteArrayList<Integer>(list);
        List<Integer> list2 = Collections.synchronizedList(list);

        int get_copyCostTime = 0;
        int get_synchCostTime = 0;
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
        CountDownLatch get_countDownLatch = new CountDownLatch(THREAD_COUNT);
        for (int i = 0; i < THREAD_COUNT; i++) {
            get_copyCostTime += executor.submit(new GetTestTask(list1, get_countDownLatch)).get();
        }
        System.out.println("CopyOnWriteArrayList add method cost time is " + get_copyCostTime);

        for (int i = 0; i < THREAD_COUNT; i++) {
            get_synchCostTime += executor.submit(new GetTestTask(list2, get_countDownLatch)).get();
        }
        System.out.println("Collections.synchronizedList add method cost time is " + get_synchCostTime);

    }


    private List<Integer> initList() {
        List<Integer> list = new ArrayList<Integer>();
        int num = new Random().nextInt(1000);
        for (int i = 0; i < NUM; i++) {
            list.add(num);
        }
        return list;
    }

    class AddTestTask implements Callable<Integer> {
        List<Integer> list;
        CountDownLatch countDownLatch;

        AddTestTask(List<Integer> list, CountDownLatch countDownLatch) {
            this.list = list;
            this.countDownLatch = countDownLatch;
        }

        @Override
        public Integer call() throws Exception {
            int num = new Random().nextInt(1000);
            long start = System.currentTimeMillis();
            for (int i = 0; i < NUM; i++) {
                list.add(num);
            }
            long end = System.currentTimeMillis();
            countDownLatch.countDown();
            return (int) (end - start);
        }
    }

    class GetTestTask implements Callable<Integer> {
        List<Integer> list;
        CountDownLatch countDownLatch;

        GetTestTask(List<Integer> list, CountDownLatch countDownLatch) {
            this.list = list;
            this.countDownLatch = countDownLatch;
        }

        @Override
        public Integer call() throws Exception {
            int pos = new Random().nextInt(NUM);
            long start = System.currentTimeMillis();
            for (int i = 0; i < NUM; i++) {
                list.get(pos);
            }
            long end = System.currentTimeMillis();
            countDownLatch.countDown();
            return (int) (end - start);
        }
    }
}