JAva単例モード5種類の書き方

学習整理
満腹モード(怠け者モード)

 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.構造関数は暴露しない(暴露すれば1部を保証できない)、自分で自分の構造を担当する.
3.怠け者式:Lazy load、使用してからロードし、スレッドではなく安全です.スレッドのセキュリティを保証する方法:
(1) synchronized getInstance().
(2)二重検査ロック(volatile).
4.餓漢式:最初から申請して、資源を浪費したが、スレッドは安全だ.
5.Holderモード:
(1)内部クラスに変更し,JVMによりスレッドセキュリティを保証する.
転載先:https://www.cnblogs.com/t0000/p/8250686.html