并发--性能调优（二） 免锁容器 CopyOnWriteArrayList VS synchronized ArrayList

免锁容器

• 免锁容器通用策略：对容器的修改可以与读取操作同时发生，只要读取者只能看到完成修改的结果即可。修改时在容器数据结构的某个部分的一个单独的副本（有时是整个数据结构的副本）上执行的，并且这个副本在修改过程中是不可视的。只有当修改完成时，被修改的结构才会自动地与主数据结构进行狡猾，之后读取者就可以看到这个修改了。
• CopyOnWriteArrayList中，写入将导致创建整个底层数组的副本，而源数组将保留在原地，使得复制的数组在被修改时，读取操作可以安全地执行。当修改完成时，一个原子性的操作将把新的数组换入，使得新的读取操作可以看到这个新的修改。
• CopyOnWriteArrayList好处：当多个迭代器同时遍历和修改这个列表时，不会跑出ConcurrentModificationException，因此不必编写特殊的代码去防范这种异常。
• CopyOnWriteArraySet将使用 CopyOnWriteArrayList来实现其免锁行为。
• ConcurrentHashMap和ConcurrentLinkedQueue使用类似的技术，允许并发的读取和写入，但是容器中只有部分内容而不是整个容器可以被复制和修改。然而，任何修改在完成之前，读取者仍旧不能看到它们。ConcurrentHashMap不会抛出ConcurrentModificationException异常。
• 乐观锁：只要从免锁容器中读取，它就会比其synchronized对应物块许多，因此获取和释放锁的开销被省掉了。
• Demo

package com21并发1;

import 生成器.Generated;
import 生成器.RandomGenerator;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by Panda on 2018/5/29.
 */
//泛型框架，用于在任何类型的容器上执行测试
public abstract class Tester<C> {
    static int testReps=1;
    static int testCycles=1000;
    static int containerSize=1000;
    abstract C containerInitializer();
    abstract void startReaderAndWriters();
    C testContainer;
    String testId;
    int nReaders;
    int nWriters;
    volatile long readResult=0;
    volatile long readTime=0;
    volatile long writeTime=0;
    CountDownLatch endLatch;

    static ExecutorService executorService= Executors.newCachedThreadPool();
    Integer[] writeData;

    Tester(String testId,int nReaders,int nWriters){
        this.testId=testId+" "+nReaders+"r "+nWriters+"w";
        this.nReaders=nReaders;
        this.nWriters=nWriters;
         writeData= Generated.array(Integer.class,new RandomGenerator.Integer(),containerSize);
        for (int i = 0; i <testReps ; i++) {
            runTest();
            readTime=0;
            writeTime=0;
        }
    }

    void runTest(){
        endLatch=new CountDownLatch(nReaders+nWriters);
        testContainer=containerInitializer();
        startReaderAndWriters();
        try{
            endLatch.await();
        }catch (InterruptedException e){
            System.out.println("endLatch interrupted");
        }

        System.out.printf("%-27s %14d %14d\n",testId,readTime,writeTime);
        if(readTime!=0&&writeTime!=0) System.out.printf("%-27s %14d\n","readTime+writeTime=",readTime+writeTime);
    }

    abstract class TestTask implements Runnable{
        abstract void test();
        abstract void putResults();
        long duration;
        public void run(){
            long startTime=System.nanoTime();
            test();
            duration=System.nanoTime()-startTime;
            synchronized (Tester.this){
                putResults();
            }
            endLatch.countDown();
        }
    }

    public static void initMain(String[] args){
        if(args.length>0) testReps=new Integer(args[0]);
        if(args.length>1) testCycles=new Integer(args[1]);
        if(args.length>2) containerSize=new Integer(args[2]);

        System.out.printf("%-27s %14s %14s\n","Type","Read time","Write time");
    }
}

package com21并发1;

import 生成器.CountingGenerator;
import 生成器.Generated;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * Created by Panda on 2018/5/29.
 */
abstract class ListTest extends Tester<List<Integer>>{
    ListTest(String testId,int nReaders,int nWriters){
        super(testId,nReaders,nWriters);
    }

    class Reader extends TestTask{
        long result=0;
        @Override
        void test() {
            for(long i=0;i<testCycles;i++){
                for (int index = 0; index <containerSize ; index++) {
                    result+=testContainer.get(index);
                }
            }
        }

        @Override
        void putResults() {
             readResult+=result;
             readTime+=duration;
        }
    }

    class Writer extends TestTask{
        @Override
        void test() {
            for (long i = 0; i <testCycles ; i++) {
                for (int index = 0; index <containerSize ; index++) {
                    testContainer.set(index,writeData[index]);
                }
            }
        }

        @Override
        void putResults() {
            writeTime+=duration;
        }
    }

    @Override
    void startReaderAndWriters() {
        for (int i = 0; i <nReaders ; i++) {
            executorService.execute(new Reader());
        }
        for (int i = 0; i <nWriters ; i++) {
            executorService.execute(new Writer());
        }
    }
}

class SynchronizedArrayListTest extends ListTest{
    @Override
    List<Integer> containerInitializer() {
        return Collections.synchronizedList(new ArrayList<Integer>(Arrays.asList(Generated.array(Integer.class, new CountingGenerator.Integer(), containerSize))));
    }
    SynchronizedArrayListTest(int nReaders,int nWriters){
        super("Synched ArrayList",nReaders,nWriters);
    }
}

class CopyOnWriteArrayListTest extends ListTest{
    @Override
    List<Integer> containerInitializer() {
        return new CopyOnWriteArrayList<>(Arrays.asList(Generated.array(Integer.class,new CountingGenerator.Integer(),containerSize)));
    }
    CopyOnWriteArrayListTest(int nReaders,int nWriters){
        super("CopyOnWriteArrayList",nReaders,nWriters);
    }
}
public class ListComparisons  {
    public static void main(String[] args) {
        Tester.initMain(args);
        new SynchronizedArrayListTest(10,0);
        new SynchronizedArrayListTest(9,1);
        new SynchronizedArrayListTest(5,5);
        new CopyOnWriteArrayListTest(10,0);
        new CopyOnWriteArrayListTest(9,1);
        new CopyOnWriteArrayListTest(5,5);
        Tester.executorService.shutdown();
    }
    /**
     * Type                             Read time     Write time
     Type                             Read time     Write time
     Synched ArrayList 10r 0w        9843812530              0
     Synched ArrayList 9r 1w         8566822836     1018582891
     readTime+writeTime=             9585405727
     Synched ArrayList 5r 5w         4350358498     4451536849
     readTime+writeTime=             8801895347
     CopyOnWriteArrayList 10r 0w      632219696              0
     CopyOnWriteArrayList 9r 1w       150430638       89725524
     readTime+writeTime=              240156162
     CopyOnWriteArrayList 5r 5w       114292802     2511493715
     readTime+writeTime=             2625786517
     */
}

解释：synchronized ArrayList无论读取者和写入者的数量是多少，都具有大致相同的性能—读取者与其他读取者竞争锁的方式与写入者不同。