实现Singleton 模式——七种实现方式

题目：设计一个类，我们只能生成该类的一个实例

[java] view plain copy print ?

1. public class Test02 {  
2.   
3.     /** 
4.      * 单例模式，懒汉式，线程安全 
5.      */  
6.     public static class Singleton {  
7.         private final static Singleton INSTANCE = new Singleton();  
8.   
9.         private Singleton() {  
10.   
11.         }  
12.   
13.         public static Singleton getInstance() {  
14.             return INSTANCE;  
15.         }  
16.     }  
17.   
18.     /** 
19.      * 单例模式，饿汉式，线程不安全 
20.      */  
21.     public static class Singleton2 {  
22.         private static Singleton2 instance = null;  
23.   
24.         private Singleton2() {  
25.   
26.         }  
27.   
28.         public static Singleton2 getInstance() {  
29.             if (instance == null) {  
30.                 instance = new Singleton2();  
31.             }  
32.   
33.             return instance;  
34.         }  
35.     }  
36.   
37.   
38.     /** 
39.      * 单例模式，饿汉式，线程安全，多线程环境下效率不高 
40.      */  
41.     public static class Singleton3 {  
42.         private static Singleton3 instance = null;  
43.   
44.         private Singleton3() {  
45.   
46.         }  
47.   
48.         public static synchronized Singleton3 getInstance() {  
49.             if (instance == null) {  
50.                 instance = new Singleton3();  
51.             }  
52.   
53.             return instance;  
54.         }  
55.     }  
56.   
57.     /** 
58.      * 单例模式，懒汉式，变种，线程安全 
59.      */  
60.     public static class Singleton4 {  
61.         private static Singleton4 instance = null;  
62.   
63.         static {  
64.             instance = new Singleton4();  
65.         }  
66.   
67.         private Singleton4() {  
68.   
69.         }  
70.   
71.         public static Singleton4 getInstance() {  
72.             return instance;  
73.         }  
74.     }  
75.   
76.     /** 
77.      * 单例模式，使用静态内部类，线程安全【推荐】 
78.      */  
79.     public static class Singleton5 {  
80.         private final static class SingletonHolder {  
81.             private static final Singleton5 INSTANCE = new Singleton5();  
82.         }  
83.   
84.         private Singleton5() {  
85.   
86.         }  
87.   
88.         public static Singleton5 getInstance() {  
89.             return SingletonHolder.INSTANCE;  
90.         }  
91.     }  
92.   
93.     /** 
94.      * 静态内部类，使用枚举方式，线程安全【推荐】 
95.      */  
96.     public enum Singleton6 {  
97.         INSTANCE;  
98.   
99.         public void whateverMethod() {  
100.   
101.         }  
102.     }  
103.   
104.     /** 
105.      * 静态内部类，使用双重校验锁，线程安全【推荐】 
106.      */  
107.     public static class Singleton7 {  
108.         private volatile static Singleton7 instance = null;  
109.   
110.         private Singleton7() {  
111.   
112.         }  
113.   
114.         public static Singleton7 getInstance() {  
115.             if (instance == null) {  
116.                 synchronized (Singleton7.class) {  
117.                     if (instance == null) {  
118.                         instance = new Singleton7();  
119.                     }  
120.                 }  
121.             }  
122.   
123.             return instance;  
124.         }  
125.     }  
126.   
127.     public static void main(String[] args) {  
128.         System.out.println(Singleton.getInstance() == Singleton.getInstance());  
129.         System.out.println(Singleton2.getInstance() == Singleton2.getInstance());  
130.         System.out.println(Singleton3.getInstance() == Singleton3.getInstance());  
131.         System.out.println(Singleton4.getInstance() == Singleton4.getInstance());  
132.         System.out.println(Singleton5.getInstance() == Singleton5.getInstance());  
133.         System.out.println(Singleton6.INSTANCE == Singleton6.INSTANCE);  
134.         System.out.println(Singleton7.getInstance() == Singleton7.getInstance());  
135.     }  
136.   
137. }  

运行结果：