免鎖容器
- 免鎖容器通用策略：對容器的修改可以與讀取操作同時發生，只要讀取者只能看到完成修改的結果即可。修改時在容器數據結構的某個部分的一個單獨的副本（有時是整個數據結構的副本）上執行的，並且這個副本在修改過程中是不可視的。只有當修改完成時，被修改的結構纔會自動地與主數據結構進行狡猾，之後讀取者就可以看到這個修改了。
- 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無論讀取者和寫入者的數量是多少，都具有大致相同的性能—讀取者與其他讀取者競爭鎖的方式與寫入者不同。
