单例模式使用 懒汉模式和饿汉模式以及使用enum方式的性能测试

本问分别使用懒汉、恶汉以及enum测试实现单例模式的不同实现，测试了他们的性能：

得出结论

（1）饿汉模式是懒汉模式的5倍左右，由于同步方法的业务方法逻辑简单，随着需要同步的业务方法复杂性变大，差距会逐渐变小。

（2）饿汉模式和enum实现的单例速度大致相等。

public class SinglePerformanceTest {

static public class CountInc {
private volatile long count = 0;

public void action() {
count++;
}
}

static public class LazySingle extends CountInc {

private static LazySingle instance;

private LazySingle() {

}

public static synchronized LazySingle getInstance() {
if (instance == null) {
instance = new LazySingle();
}
return instance;
}
}

static public class StarveSingle extends CountInc {

private static StarveSingle instance = new StarveSingle();

private StarveSingle() {

}

public static StarveSingle getInstance() {

return instance;
}

}

static enum SINGLE {
INSTANCE;

private static volatile long count = 0;

public void action() {
count++;
}
}

static class LazySingleTest extends Test {

public LazySingleTest(String id, CyclicBarrier barrier, long count,
int threadNum, ExecutorService executor) {
super(id, barrier, count, threadNum, executor);
}

@Override
protected void test() {
LazySingle.getInstance().action();

}
}

static class StarveSingleTest extends Test {

public StarveSingleTest(String id, CyclicBarrier barrier, long count,
int threadNum, ExecutorService executor) {
super(id, barrier, count, threadNum, executor);
}

@Override
protected void test() {
StarveSingle.getInstance().action();

}

}

static class EnumSingleTest extends Test {

public EnumSingleTest(String id, CyclicBarrier barrier, long count,
int threadNum, ExecutorService executor) {
super(id, barrier, count, threadNum, executor);
}

@Override
protected void test() {
SINGLE.INSTANCE.action();
}

}

static void testPerformanceTemplate(String id, long count, int threadNum,
final ExecutorService executor) {
final CyclicBarrier barrier = new CyclicBarrier(threadNum + 1,
new Thread() {

@Override
public void run() {
// System.err.println("-----------------");
}
});

System.out.println("==============================");
System.out.println("count = " + count + "/t" + "Thread Count = "
+ threadNum);

new LazySingleTest("LazySingleTest ", barrier, count, threadNum,
executor).startTest();
new StarveSingleTest("StarveSingleTest ", barrier, count, threadNum,
executor).startTest();
new EnumSingleTest("EnumSingleTest ", barrier, count, threadNum,
executor).startTest();

executor.shutdownNow();

System.out.println("==============================");
}

private static int COUNT = 1000000;
private static int THREAD_NUM = 10;

public static void main(String[] args) {
for (int i = 1; i < 5; i++) {
ExecutorService executor = Executors.newFixedThreadPool(THREAD_NUM
* i);
testPerformanceTemplate(null, COUNT * i, THREAD_NUM * i, executor);
}
}
}

结果

==============================
count = 1000000	Thread Count = 10
LazySingleTest  = 4718
StarveSingleTest  = 766
EnumSingleTest  = 766
==============================
==============================
count = 2000000	Thread Count = 20
LazySingleTest  = 18656
StarveSingleTest  = 3078
EnumSingleTest  = 3047
==============================
==============================
count = 3000000	Thread Count = 30
LazySingleTest  = 41672
StarveSingleTest  = 6922
EnumSingleTest  = 6843
==============================
==============================
count = 4000000	Thread Count = 40
LazySingleTest  = 65344
StarveSingleTest  = 12328
EnumSingleTest  = 12328
==============================