单例模式

单例模式可以分为5种，懒汉式/饿汉/枚举/静态内部类/双重校验锁

懒汉：

1. public class Singleton {  
2.     private static Singleton instance;  
3.     private Singleton (){}  
4.     public static synchronized Singleton getInstance() {  
5.     if (instance == null) {  
6.         instance = new Singleton();  
7.     }  
8.     return instance;  
9.     }  
10. }  

锁加在方法上，效率低。类不会自动加载，共享数据只在调用getInstance时才实例化。

 

饿汉

11. public class Singleton {  
12.     private static Singleton instance = new Singleton();  
13.     private Singleton (){}  
14.     public static Singleton getInstance() {  
15.     return instance;  
16.     }  
17. }  

基于classloader机制避免了并发访问的冲突，而且不用加锁，效率较高。但在类加载过程中共享数据即实例化了，未实现lazy load。

 

枚举

18. public enum Singleton {  
19.     INSTANCE;  
20.     public void whateverMethod() {  
21.     }  
22. } 

据说是非常好的一种单例模式，解决了并发问题且实现lazy load。但写法诡异，不常用。

 

静态内部类

 

23. public class Singleton {  
24.     private static class SingletonHolder {  
25.     private static final Singleton INSTANCE = new Singleton();  
26.     }  
27.     private Singleton (){}  
28.     public static final Singleton getInstance() {  
29.     return SingletonHolder.INSTANCE;  
30.     }  
31. }  

较为常用的一种单例。实现了lazy load。在外部类加载时不进行实例化，仅当getInstance()调用时才实例化内部类、实例化内部类中的静态变量。很好的机制，尤其在外部类可能在其他地方被多次使用时。而且是线程安全的，基于classloader的加载机制，内部类的构建依赖于外部类的构造函数，但外部类的构造函数是原子的，因此无需同步。

 

双重校验锁

 

32. public class Singleton {  
33.     private volatile static Singleton singleton;  
34.     private Singleton (){}  
35.     public static Singleton getSingleton() {  
36.     if (singleton == null) {  
37.         synchronized (Singleton.class) {  
38.         if (singleton == null) {  
39.             singleton = new Singleton();  
40.         }  
41.         }  
42.     }  
43.     return singleton;  
44.     }  
45. }  

 

也是较为常用的一种单例，但对性能有一定影响。

总而言之，每种单例模式都有自己的适用范围。应根据具体的业务场景进行选择。