计数器实现（三个版本）

运用atomic实现

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicCounter{
    private AtomicInteger value = new AtomicInteger(0);
    public synchronized int getValue(){
        return value.get();
    }
    public synchronized  int increment(){
        int intValue;
        int next;
        for(;;){
            intValue = value.get();
            next = intValue + 1;
            if(value.compareAndSet(intValue,next))
                    return next;
        }
    }
}

测试类

import java.util.*;
public class AtomicCounterTest{
    public static void main(String[] args){
        int time = Integer.parseInt(args[0]);
        AtomicCounter counter = new AtomicCounter();
        long start = System.currentTimeMillis();
        for(int i = 0;i < time;i ++){
            new AtomicThread(counter).start();
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);

    }
}
class AtomicThread extends Thread{
    private AtomicCounter counter ;
    public AtomicThread(AtomicCounter counter){
        this.counter = counter;
    }
    public void run(){
        counter.increment();
    }
}

运用cas实现

public class SimulatedCAS{
    private int value = 0;
    public synchronized int getValue(){
        return value;
    }
    public synchronized int compareAndSwap(int expectValue,int newValue){
        if(expectValue == value){
            value = newValue;
            return expectValue;
        }
        return value;
    }
}


public class CasCounter{
    private SimulatedCAS value = new SimulatedCAS();
    public int getValue(){
        return value.getValue();
    }

    public int increment(){
        int oldValue = value.getValue();
        while(value.compareAndSwap(oldValue,oldValue + 1) != oldValue)
           oldValue = value.getValue();
        return oldValue + 1;
    }
}

测试类

import java.util.*;
public class CasCounterTest{
    public static void main(String[] args){
        int time = Integer.parseInt(args[0]);
        CasCounter counter = new CasCounter();
        long start = System.currentTimeMillis();
        for(int i =0 ;i < time;i ++){
            new CasTestThread(counter).start();
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

class CasTestThread extends Thread{
    private CasCounter counter;
    public CasTestThread(CasCounter counter){
        this.counter = counter;
    }
    public void run(){
        counter.increment();
    }
}

运用同步实现

public class SynCounter{
    private int value = 0;
    public synchronized int getValue(){
        return value;
    }
    public synchronized int increment(){
        return this.value += 1;
    }
}

测试类

import java.util.*;
public class SynCounterTest{
    public static void main(String[] args){
        int time = Integer.parseInt(args[0]);
        SynCounter counter = new SynCounter();
        long start = System.currentTimeMillis();
        for(int i = 0;i < time;i ++)
        {
            new SynCounterThread(counter).start();
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);

    }
}

class SynCounterThread extends Thread{
    private SynCounter  counter;
    public SynCounterThread(SynCounter counter){
        this.counter = counter;
    }
    public void run(){
        this.counter.increment();
    }
}