单例模式

 1、是不是号称恶汉，就是类加载就初始化了

[java]  view plain copy

1. package com.zhy.pattern.singlton;  
2.   
3. public class Singleton  
4. {  
5.     private static Singleton instance = new Singleton();  
6.       
7.     public static Singleton getInstance()  
8.     {  
9.         return instance ;  
10.     }  
11. }  

2、懒汉，我喜欢这种，需要双重判断

[java]  view plain copy

1. package com.zhy.pattern.singlton;  
2.   
3.   
4. public class Singleton02  
5. {  
6.     private static Singleton02 instance;  
7.   
8.     public static Singleton02 getInstance()  
9.     {  
10.         if (instance == null)  
11.         {  
12.             synchronized (Singleton02.class)  
13.             {  
14.                 if (instance == null)  
15.                 {  
16.                     instance = new Singleton02();  
17.                 }  
18.             }  
19.         }  
20.         return instance;  
21.     }  
22. }  

3、使用Java的枚举，还是很推荐的，简单的跟神马一样，如果对枚举不熟悉，小google一下

[java]  view plain copy

1. public enum Singleton03  
2. {  
3.     INSTANCE;  
4. }  

4、使用一个持有类，主要是为了不在初始化的时候加载

[java]  view plain copy

1. package com.zhy.pattern.singlton;  
2.   
3. public class Singleton04  
4. {  
5.     private static final class InstanceHolder  
6.     {  
7.         private static Singleton04 INSTANCE = new Singleton04();  
8.     }  
9.   
10.     public static Singleton04 getInstance()  
11.     {  
12.         return InstanceHolder.INSTANCE;  
13.     }  
14. }  

        好了，就这么多，以上4种都是比较推荐使用的，除了第一种会类加载的时候初始化，其他3种都不会，且4种都保证线程安全，特殊情况（除了多个类加载器，和你非要通过反射等手段生成多个对象）不考虑。

        原文请猛戳这里