使用无锁的方式和有锁的方式的程序性能对比

这里分别使用有锁和无锁两种方式，对一个数值进行增加，一直增加到100000，然后输出使用时间的长短。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class TestAtomic {

    // 设置线程数量
    private static int N = 1000;
    // 设置最大值
    private static int M = 1000000;

    /**
     * 无锁方法
     * 
     * @throws InterruptedException
     */
    private static void atomicMethod() throws InterruptedException {
        AtomicRun atomicRun = new AtomicRun();
        AtomicRun.endValue = M;

        ExecutorService service = Executors.newFixedThreadPool(N);
        // 开始时间
        long starttime = System.currentTimeMillis();
        for (int i = 0; i < N; i++) {
            service.submit(atomicRun);
        }
        service.shutdown();
        service.awaitTermination(Integer.MAX_VALUE, TimeUnit.MILLISECONDS);
        // 结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("无锁线程数量为 ： " + N + " 开始时间为 ： " + starttime
                + " 结束时间为 ： " + endTime + " 耗费时间为 ： " + (endTime - starttime)
                + "ms" + " value:" + AtomicRun.atomicInteger);
    }

    /**
     * 加锁方法
     * 
     * @throws InterruptedException
     */
    private static void synMethod() throws InterruptedException {
        SynRun synRun = new SynRun();
        SynRun.endValue = M;

        ExecutorService service = Executors.newFixedThreadPool(N);
        long starttime = System.currentTimeMillis();
        for (int i = 0; i < N; i++) {
            service.submit(synRun);
        }
        service.shutdown();
        service.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
        long endTime = System.currentTimeMillis();
        System.out.println("有锁线程数量为 ： " + N + " 开始时间为 ： " + starttime
                + " 结束时间为 ： " + endTime + " 耗费时间为 ： " + (endTime - starttime)
                + "ms" + " value:" + AtomicRun.atomicInteger);
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("当线程数量为 ： " + N + "时：");
        atomicMethod();
        synMethod();
    }
}

/**
 * 
 * @author 秦孔祥
 * 
 */
class AtomicRun implements Runnable {

    protected static AtomicInteger atomicInteger = new AtomicInteger();
    protected static int endValue;

    @Override
    public void run() {
        int startValue = atomicInteger.get();
        while (startValue < endValue) {
            startValue = atomicInteger.incrementAndGet();
        }
    }
}

class SynRun implements Runnable {

    protected static int startValue;
    protected static int endValue;

    @Override
    public void run() {
        while (startValue < endValue) {
            addValue();
        }
    }

    private synchronized void addValue() {
        startValue++;
    }
}