原文地址:https://www.cnblogs.com/t0000/p/8250686.html
飽漢模式(懶漢模式)
1 // 飽漢
2 // UnThreadSafe
3 public class Singleton1 {
4 private static Singleton1 singleton = null;
5 private Singleton1() {
6 }
7 public static Singleton1 getInstance() {
8 if (singleton == null) {
9 singleton = new Singleton1();
10 }
11 return singleton;
12 }
13 }
優點：懶加載啓動快，資源佔用小，使用時才實例化，無鎖。
缺點：非線程安全。
飽漢模式(懶漢模式)--線程安全
1 public class Singleton {
2
3 /**
4 * 定義一個變量來存儲創建好的類實例
5 */
6
7 private static Singleton uniqueInstance = null;
8
9 /**
10 * 私有化構造方法，好在內部控制創建實例的數目
11 */
12
13 private Singleton(){
14 }
15
16 /**
17 * 定義一個方法來爲客戶端提供類實例
18 * @return 一個Singleton的實例
19 */
20
21 public static synchronized Singleton getInstance(){
22
23 //判斷存儲實例的變量是否有值
24 if(uniqueInstance == null){
25 //如果沒有，就創建一個類實例，並把值賦值給存儲類實例的變量
26 uniqueInstance = new Singleton();
27 }
28
29 //如果有值，那就直接使用
30 return uniqueInstance;
31 }
32
33 /**
34 * 示意方法，單例可以有自己的操作
35 */
36
37 public void singletonOperation(){
38
39 //功能處理
40
41 }
42
43 /**
44 * 示意屬性，單例可以有自己的屬性
45 */
46
47 private String singletonData;
48
49 /**
50 * 示意方法，讓外部通過這些方法來訪問屬性的值
51 * @return 屬性的值
52 */
53
54 public String getSingletonData(){
55
56 return singletonData;
57
58 }
59
60 }
優點：同上，但加鎖了。
缺點：synchronized 爲獨佔排他鎖，併發性能差。即使在創建成功以後，獲取實例仍然是串行化操作。
飽漢模式(懶漢模式)--雙重加鎖檢查DCL（Double Check Lock）
1 public class Singleton {
2
3 /**
4 * 對保存實例的變量添加volatile的修飾
5 */
6
7 private volatile static Singleton instance = null;
8
9 private Singleton(){
10
11 }
12
13 public static Singleton getInstance(){
14
15 //先檢查實例是否存在，如果不存在才進入下面的同步塊
16
17 if(instance == null){
18
19 //同步塊，線程安全的創建實例
20
21 synchronized(Singleton.class){
22
23 //再次檢查實例是否存在，如果不存在才真的創建實例
24
25 if(instance == null){
26
27 instance = new Singleton();
28
29 }
30
31 }
32
33 }
34
35 return instance;
36
37 }
38
39 }
優點：懶加載，線程安全。
注：實例必須有 volatile 關鍵字修飾，其保證初始化完全。
餓漢模式
1 public class Singleton {
2
3 //4：定義一個靜態變量來存儲創建好的類實例
4
5 //直接在這裏創建類實例，只會創建一次
6
7 private static Singleton instance = new Singleton();
8
9 //1：私有化構造方法，好在內部控制創建實例的數目
10
11 private Singleton(){
12
13 }
14
15 //2：定義一個方法來爲客戶端提供類實例
16
17 //3：這個方法需要定義成類方法，也就是要加static
18
19 //這個方法裏面就不需要控制代碼了
20
21 public static Singleton getInstance(){
22
23 //5：直接使用已經創建好的實例
24
25 return instance;
26
27 }
28
29 }
優點：餓漢模式天生是線程安全的，使用時沒有延遲。
缺點：啓動時即創建實例，啓動慢，有可能造成資源浪費。
Holder模式
1 public class Singleton {
2 /**
3 * 類級的內部類，也就是靜態的成員式內部類，該內部類的實例與外部類的實例
4 * 沒有綁定關係，而且只有被調用到纔會裝載，從而實現了延遲加載
5 */
6 private static class SingletonHolder{
7 /**
8 * 靜態初始化器，由JVM來保證線程安全
9 */
10 private static Singleton instance = new Singleton();
11 }
12 /**
13 * 私有化構造方法
14 */
15 private Singleton(){
16 }
17 public static Singleton getInstance(){
18 return SingletonHolder.instance;
19 }
20 }
優點：將懶加載和線程安全完美結合的一種方式（無鎖）。（推薦）
備註：
1. 全局共享，獨一份；
2. 構造函數不暴露（如果暴露便不能保證一份），自己負責自己的構造；
3. 懶漢式：Lazy load，用到才加載，非線程安全。如何保證線程安全呢：
（1） synchronized getInstance()。
（2）雙重檢查加鎖（volatile）。
4. 餓漢式：一開始就申請好，浪費了點資源，但其線程安全。
5. Holder模式：
（1）改成內部類，由JVM保證線程安全性。