性能测试:带和不带双重检查锁定的单例类

Question

我有两个单例类的实现

public class Test2 {
private static Test2 _instance=new Test2();
private Test2(){
}
public static synchronized Test2 getInstance(){
    if(_instance == null){          
        _instance = new Test2();
    }
    return _instance;
}
}

:

public class TestSingleton {
private static TestSingleton _instance=new TestSingleton();
private TestSingleton(){
}
public static TestSingleton getInstance(){
    if (_instance == null) {
        synchronized (TestSingleton.class) {
            if (_instance == null) {
        _instance = new TestSingleton();
            }
        }
    }
    return _instance;
}

我想用时间来参数化我的发现，我所做的是:

Callable<Long> task = new Callable<Long>() {
        @Override
        public Long call() throws Exception {
            long start = System.nanoTime();
            **TestSingleton.getInstance();**
            long end = System.nanoTime();
            return end - start;
        }
    };
    for (int i = 0; i < 100000; i++) {
        futList.add(es1.submit(task));
    }
    for (Future<Long> fut : futList) {
        try {
            totalTime1.getAndAdd(fut.get());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    System.out.println("Time taken by S1   " + totalTime1.get());
            .
            .
            ExecutorService es2 = Executors.newFixedThreadPool(threadpool);
    Callable<Long> task1 = new Callable<Long>() {
        @Override
        public Long call() throws Exception {
            long start = System.nanoTime();
            Test2.getInstance();
            long end = System.nanoTime();
            return end - start;
        }
    };
    for (int i = 0; i < 100000; i++) {
        futList1.add(es2.submit(task1));
    }
    for (Future<Long> fut : futList1) {
        try {
            totalTime2.getAndAdd(fut.get());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    System.out.println("Time taken by S2   " + totalTime2.get());

我得到的结果是:

S1 4636498占用的时间S2 5127865

第一个问题这是正确的方法吗?第二，即使我在两个call()中注释getinstances方法，我也会得到两个相同块的不同执行时间:

S1 1506640占用的时间S2 2156172

Answer 1

不要对每次执行进行测量并将时间相加，否则单个测量会有太多的不准确性。相反，获取开始时间，执行100000次，获取结束时间。此外，在开始测量之前执行1000次，以避免启动成本造成的偏差。