單例模式在實際應用中使用非常廣泛，比如日誌寫入，單例模式可以避免錯誤，資料庫連線可以避免鎖死，用例執行可以避免重複呼叫。

先是列舉實現法：

public enum Singleton01 {
	INSTANCE;

	public void operator() {
		System.out.println("Operator");
	}
}

public class Singleton02 {
	private static class Module {
		private static final Singleton02 instance = new Singleton02();
	}

	private Singleton02() {
		;
	}

	public static Singleton02 getInstance() {
		return Module.instance;
	}
}
 

public class Singleton03 {
	private static final Singleton03 instance = new Singleton03();

	private Singleton03() {
	}
	
	public static Singleton03 getInstance() {
		return instance;
	}
}

public class Singleton04 {
	private static Singleton04 instance;

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

import java.util.concurrent.CountDownLatch;

public class Client2 {
	private static int threadCount = 10;
	private static long jobCountPerThread = 1000000L;

	public static void main(String[] args) throws InterruptedException {
		testEnum();
		testInnerClass();
		testHungeryClass();
		testLazyClass();
	}

	public static void testEnum() throws InterruptedException {
		long startTime = System.currentTimeMillis();

		CountDownLatch countDownLatch = new CountDownLatch(threadCount);

		for (int i = 0; i < threadCount; i++) {
			new Thread(new Runnable() {

				@Override
				public void run() {
					// TODO Auto-generated method stub
					for (int i = 0; i < jobCountPerThread; i++) {
						Singleton01 s1 = Singleton01.INSTANCE;
					}

					countDownLatch.countDown();
				}

			}).start();
		}

		countDownLatch.await();
		long endTime = System.currentTimeMillis();
		System.out.println("列舉單例模式總消耗時間：" + (endTime - startTime) + "毫秒");
	}

	public static void testInnerClass() throws InterruptedException {
		long startTime = System.currentTimeMillis();
		CountDownLatch countDownLatch = new CountDownLatch(threadCount);

		for (int i = 0; i < threadCount; i++) {
			new Thread(new Runnable() {

				@Override
				public void run() {
					// TODO Auto-generated method stub
					for (int i = 0; i < jobCountPerThread; i++) {
						Singleton02 s1 = Singleton02.getInstance();
					}

					countDownLatch.countDown();
				}

			}).start();
		}

		countDownLatch.await();
		long endTime = System.currentTimeMillis();
		System.out.println("內部類單例模式總消耗時間：" + (endTime - startTime) + "毫秒");
	}

	public static void testHungeryClass() throws InterruptedException {
		long startTime = System.currentTimeMillis();
		CountDownLatch countDownLatch = new CountDownLatch(threadCount);

		for (int i = 0; i < threadCount; i++) {
			new Thread(new Runnable() {

				@Override
				public void run() {
					// TODO Auto-generated method stub
					for (int i = 0; i < jobCountPerThread; i++) {
						Singleton03 s1 = Singleton03.getInstance();
					}

					countDownLatch.countDown();
				}

			}).start();
		}

		countDownLatch.await();
		long endTime = System.currentTimeMillis();
		System.out.println("餓漢式單例模式總消耗時間：" + (endTime - startTime) + "毫秒");
	}

	public static void testLazyClass() throws InterruptedException {
		long startTime = System.currentTimeMillis();
		CountDownLatch countDownLatch = new CountDownLatch(threadCount);

		for (int i = 0; i < threadCount; i++) {
			new Thread(new Runnable() {

				@Override
				public void run() {
					// TODO Auto-generated method stub
					for (int i = 0; i < jobCountPerThread; i++) {
						Singleton04 s1 = Singleton04.getInstance();
					}

					countDownLatch.countDown();
				}

			}).start();
		}

		countDownLatch.await();
		long endTime = System.currentTimeMillis();
		System.out.println("懶漢式單例模式總消耗時間：" + (endTime - startTime) + "毫秒");
	}
}
 

由圖上很簡單可以看出，各自不同的特點，除了懶漢式，其它幾種效率都不錯，但是餓漢式因為不是延遲載入，所以某些場合下不適合，可能會造成開銷增加，懶漢式支援延遲載入，但是因為執行緒安全問題，所以效率下降比較嚴重，考慮綜合因素，結論是列舉型別是執行緒安全效率又高的，同時是非延遲載入的，內部類是支援延遲載入的，也是執行緒安全的，而且效能也不錯。