餓漢式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
/** * 餓漢式 * 類加載到內(nèi)存后，就是實例化一個單例，JVM保證線程安全 * 簡單使用：推薦使用 * 唯一缺點：不管用與不用，類加載時就會完成實例化 */public class Demo01 { //開始先新建一個對象 private static final Demo01 INSTANCE = new Demo01(); //構(gòu)造 private Demo01(){}; //調(diào)用 getInstance 方法時返回 INSTANCE，唯一創(chuàng)建的對象 public static Demo01 getInstance(){ return INSTANCE; } public static void main(String[] args) { Demo01 m1 = Demo01.getInstance(); Demo01 m2 = Demo01.getInstance(); //結(jié)果為true System.out.println(m1 == m2); }} |
|
1
2
3
|
單例模式（餓漢式）優(yōu)點：餓漢式是典型的空間換時間，當(dāng)類裝載的時候就會創(chuàng)建類實例，不管你用不用，先創(chuàng)建出來，然后每次調(diào)用的時候，就不需要再判斷了，節(jié)省了運行時間。缺點：不管用與不用，類加載時就會完成實例化，會浪費一定的內(nèi)存空間改進方法：讓對象在使用的時候在進行創(chuàng)建。------> 懶漢式 |
懶漢式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
/** * 懶漢式 * 類加載到內(nèi)存后，就是實例化一個單例，JVM保證線程不安全 * 唯一缺點：雖然達到了按需的目的，但卻帶來線程不安全問題 */public class Demo02 { private static Demo02 INSTANCE ; private Demo02(){}; public static Demo02 getInstance(){ //判斷 INSTANCE 是否為空 if(INSTANCE == null){ try{ Thread.sleep(1); }catch (InterruptedException e){ e.printStackTrace(); } INSTANCE = new Demo02(); } return INSTANCE; } public static void main(String[] args) { for(int i = 0 ; i < 100 ; i++){ new Thread(()-> //輸出該對象的hashcode值，通過對比值是否相等來判斷是不是唯一的對象 System.out.println(Demo02.getInstance().hashCode()) ).start(); } }} |
|
1
2
3
|
單例模式（懶漢式）優(yōu)點：懶漢式是典型的時間換空間，也就是每次獲取實例都會進行判斷，看是否需要創(chuàng)建實例，浪費判斷的時間。當(dāng)然，如果一直沒有人使用的話，那就不會創(chuàng)建實例，則節(jié)約內(nèi)存空間。缺點：懶漢式在多個線程進行訪問時有可能會出現(xiàn)多個不同的對象。改進方法：對創(chuàng)建方法getInstance加鎖 ------> 懶漢式（加鎖synchronized） |
懶漢式（加鎖synchronized）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
/** * 懶漢式(加鎖) * 類加載到內(nèi)存后，就是實例化一個單例，給創(chuàng)建對象的方法的加鎖，JVM保證線程安全 * 唯一缺點：雖然加鎖之后可以保證線程是安全的，但會使得整個方法變慢。 */public class Demo03 { private static Demo03 INSTANCE ; private Demo03(){}; //方法加鎖 public static synchronized Demo03 getInstance(){ //業(yè)務(wù)邏輯 //判斷 INSTANCE 是否為空 if(INSTANCE == null){ try{ Thread.sleep(1); }catch (InterruptedException e){ e.printStackTrace(); } INSTANCE = new Demo03(); } return INSTANCE; } public void m(){ System.out.println("m"); } public static void main(String[] args) { for(int i = 0 ; i < 100 ; i++){ new Thread(()-> System.out.println(Demo03.getInstance().hashCode()) ).start(); } }} |
|
1
2
3
|
單例模式（懶漢式（加鎖））優(yōu)點：懶漢式（加鎖）可以保證線程的安全性，但是當(dāng)上鎖的方法getInstance中存在業(yè)務(wù)邏輯代碼時，會拉低整個對象創(chuàng)建過程中速度。缺點：對整個方法加鎖，降低了方法運行的時間改進方法：對創(chuàng)建方法的程序塊進行上鎖，業(yè)務(wù)邏輯代碼部分不上鎖 -------->懶漢式（部分加鎖synchronized） |
懶漢式（部分加鎖synchronized）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
/** * 懶漢式(部分加鎖) * 類加載到內(nèi)存后，就是實例化一個單例，給創(chuàng)建對象的方法的部分加鎖，降低時間 */public class Demo04 { private static Demo04 INSTANCE ; private Demo04(){}; //方法加鎖 public static Demo04 getInstance(){ //業(yè)務(wù)邏輯 //判斷 INSTANCE 是否為空 if(INSTANCE == null){ //對方法的部分代碼塊進行上鎖 synchronized (Demo04.class){ try{ Thread.sleep(1); }catch (InterruptedException e){ e.printStackTrace(); } INSTANCE = new Demo04(); } } return INSTANCE; } public void m(){ System.out.println("m"); } public static void main(String[] args) { for(int i = 0 ; i < 100 ; i++){ new Thread(()-> System.out.println(Demo04.getInstance().hashCode()) ).start(); } }} |
|
1
2
3
|
單例模式（部分加鎖懶漢式）優(yōu)點：加快了程序的運行，只對創(chuàng)建對象的部分進行加鎖缺點：通過if判斷后會有多個線程在等待線程資源，等第一個線程執(zhí)行完成后還會進行第二個線程創(chuàng)建對象。改進方法：加入兩層if判斷可以防止該問題出現(xiàn) -------->雙層檢查鎖 |
懶漢式（DCL）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
/** * 懶漢式(DCL) * Double Check Lock */public class Demo04 { private static Demo04 INSTANCE ; private Demo04(){}; //方法加鎖 public static Demo04 getInstance(){ //業(yè)務(wù)邏輯 //判斷 INSTANCE 是否為空 if(INSTANCE == null){ //對方法的部分代碼塊進行上鎖 synchronized (Demo04.class){ //再次進行判斷，檢查 INSTANCE 是否為空 if(INSTANCE == null){ try{ Thread.sleep(1); }catch (InterruptedException e){ e.printStackTrace(); } } INSTANCE = new Demo04(); } } return INSTANCE; } public void m(){ System.out.println("m"); } public static void main(String[] args) { for(int i = 0 ; i < 100 ; i++){ new Thread(()-> System.out.println(Demo04.getInstance().hashCode()) ).start(); } }} |
|
1
2
3
|
單例模式（懶漢式DCL）優(yōu)點：加快了對象創(chuàng)建的時間，同時保證了線程的安全性。缺點：當(dāng)對象發(fā)生指令重排時，第二個線程雖然拿到了對象，但是是拿到的不完整的對象，容易出現(xiàn)問題改進方法：給該方法加上volatile關(guān)鍵字進行上鎖可以防止指令重排問題。 |
延伸一下：為什么要用兩層if判斷呢？
答：因為使用兩層if可以提高方法的運行速度，因為if判斷消耗的時間較少，但是synchronized 消耗的時間卻很大。在外面加上一層if，可以幫助過濾掉很多線程訪問。
懶漢式（DCL）最終版
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
/** * 懶漢式(DCL) * Double Check Lock */public class Demo04 { private static volatile Demo04 INSTANCE ; private Demo04(){}; //方法加鎖 public static Demo04 getInstance(){ //業(yè)務(wù)邏輯 //判斷 INSTANCE 是否為空 if(INSTANCE == null){ //對方法的部分代碼塊進行上鎖 synchronized (Demo04.class){ //再次進行判斷，檢查 INSTANCE 是否為空 if(INSTANCE == null){ try{ Thread.sleep(1); }catch (InterruptedException e){ e.printStackTrace(); } } INSTANCE = new Demo04(); } } return INSTANCE; } public void m(){ System.out.println("m"); } public static void main(String[] args) { for(int i = 0 ; i < 100 ; i++){ new Thread(()-> System.out.println(Demo04.getInstance().hashCode()) ).start(); } }} |
對 INSTANCE 進行上鎖可以防止指令重排，保證對象的完整性。
延伸：DCL模式為什么要加上volatile ？
答：我們要從java對象創(chuàng)建過程和CPU亂序執(zhí)行兩個方面考慮。
java對象創(chuàng)建過程可分為：
|
1
2
3
|
1：內(nèi)存中分配空間2：初始化對象3：變量與對象關(guān)聯(lián) |
當(dāng)發(fā)生指令重排是順序變?yōu)?/p>
|
1
2
3
|
1：內(nèi)存中分配空間3：變量與對象關(guān)聯(lián)2：初始化對象 |
第一個線程訪問時，發(fā)生指令重排，對象剛創(chuàng)建一半，還未對對象內(nèi)部的值進行初始化賦值。此時第二個線程進行訪問，此時他讀取到的就是創(chuàng)建到一半的對象，初始化為空的對象。最終就會導(dǎo)致對象不完整。
靜態(tài)內(nèi)部類
加載外部類時不會加載內(nèi)部類，只有第一次調(diào)用getInstance方法時，JVM才加載 Singleton04Holder 并初始化INSTANCE ，只有一個線程可以獲得對象的初始化鎖，其他線程無法進行初始化，保證對象的唯一性。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class Demo04 { private Demo04 () { } private static class Demo04Holder { private final static Demo04 INSTANCE = new Demo04 (); } public static Demo04 getInstance() { return Demo04Holder.INSTANCE; } public static void main(String[] args) { for(int i=0; i<100; i++) { new Thread(()->{ System.out.println(Demo04.getInstance().hashCode()); }).start(); } }} |
總結(jié)
本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關(guān)注服務(wù)器之家的更多內(nèi)容！
原文鏈接：https://blog.csdn.net/weixin_43893423/article/details/121031279
