CopyOnWriteArrayListの簡単な使用と性能テスト

CopyOnWriteArrayListは同期Listの代わりに使用され、場合によってはより良い同時性能があり、反復時にロックやコピーを必要としない.変更するたびに、新しいコンテナのコピーが作成され、再パブリッシュされます.
次はソースです.

    // ， ， ， 
    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();
        }
    }

    // ， 
    private E get(Object[] a, int index) {
        return (E) a[index];
    }

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

利点:複数のスレッドは同時にこのコンテナを反復することができ、相互に干渉したり、コンテナを修正するスレッドと干渉したりすることはありません.つまり、C o n c u r r e n tModificationExceptionは放出されず、戻ってきた要素は反復器の作成時の要素と完全に一致し、その後の修正による影響を考慮する必要はありません.
欠点:
1.要素を追加するとコピーが作成され、コピーの占有量が大きい場合はgcが増加し、深刻な場合は対応する時間に影響を与える可能性があります.
2.データはリアルタイム性が保証されず、古いデータが読める可能性があります.
 
テストコードを貼り付けます.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author wanting
 *
 */
public class ListPerformanceTest {
	//  
	private static int threadNum;
	//  
	private static int initCapacity;
	//  
	private static int loop;

	private static CountDownLatch startLatch;
	private static CountDownLatch endLatch;

	private static List cowList;
	//  
	private volatile static double cowListTotalCost;

	private static List syncList;
	//  
	private volatile static double syncListTotalCost;

	public ListPerformanceTest(int threadNum, int initCapacity, int loop) {
		ListPerformanceTest.initCapacity = initCapacity;
		ListPerformanceTest.threadNum = threadNum;
		ListPerformanceTest.loop = loop;
		startLatch = new CountDownLatch(threadNum);
		endLatch = new CountDownLatch(threadNum);
		cowList = new CopyOnWriteArrayList<>(new ArrayList<>(initCapacity));
		syncList = Collections.synchronizedList(new ArrayList<>(initCapacity));
		initList();
	}

	public void initList() {
		for (int i = 0; i < initCapacity; i++) {
			cowList.add(i + "");
			syncList.add(i + "");
		}
	}

	public static void testPerformance(List list) {
		long t1 = System.nanoTime();
		Random random = new Random();
		for (int i = 0; i < loop; i++) {
			int index = random.nextInt(initCapacity);
			list.get(index);
		}
		long t2 = System.nanoTime();
		double costTime = (t2 - t1) / 1000000d;
		if (list instanceof CopyOnWriteArrayList) {
			cowListTotalCost = cowListTotalCost + costTime;
		} else {
			syncListTotalCost = syncListTotalCost + costTime;
		}
		// System.out.println(list.getClass() + " ：" + costTime + " ");
	}

	public static void addEle(String element) {
		cowList.add(element);
		syncList.add(element);
	}

	public static void main(String[] args) {
		ListPerformanceTest listPerformanceTest = new ListPerformanceTest(500, 100000, 10000);
		ExecutorService pool = Executors.newFixedThreadPool(threadNum);
		for (int i = 1; i <= threadNum; i++) {
			final int flag = i;
			pool.submit(new Runnable() {

				@Override
				public void run() {
					try {
						startLatch.await();
						 //if (flag % 2 == 0) {
						 //addEle(flag + "");
						// }
						testPerformance(cowList);
						testPerformance(syncList);
					} catch (Exception e) {
						e.printStackTrace();
					}
					endLatch.countDown();
				}
			});
			startLatch.countDown();
		}
		try {
			endLatch.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("cowz ：" + cowListTotalCost + " ， ：" + (cowListTotalCost / (threadNum * 1.0) + " "));
		System.out
				.println("sync ：" + syncListTotalCost + " ， ：" + (syncListTotalCost / (threadNum * 1.0) + " "));
		pool.shutdown();
	}

まとめ:反復操作が修正操作よりはるかに多い場合に適しています.CopyOnWriteArrayListの性能は、同時量の増加または反復回数の増加に伴って同期Listよりも優れている.