单例模式的懒加载（转）

首先推荐种最好的单例模式实现方式（没有之一）

[java]  view plain  copy

1. public class Manager {  
2.   
3.     private Manager() {  
4.           
5.     }  
6.       
7.     public static Manager getInstance() {  
8.         return ManagerHolder.instance;  
9.     }  
10.       
11.     private static class ManagerHolder {  
12.         private static final Manager instance = new Manager();  
13.     }  
14. }  

然后解释下为什么要用这种方式：

* 内部类只在需要的时候才会被类加载器加载，实现了懒加载，即在需要的时候才实例化出一个Manager,而且是唯一的一个

* 同时由于instance是static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性

（即使在高并发的情况下多个线程同时访问getInstance()方法 也能够保证实例的唯一性）

其他没有采用内部类的实现方式 以下是目前见过最好的：

[java]  view plain  copy

1. public static class SingletonOptimizeLazy {  
2. 　　　　static SingletonOptimizeLazy instance = null;  
3. 　　　　public static SingletonOptimizeLazy getInstance() {  
4. 　　　　　　if (instance == null) {  
5. 　　　　　　　　createInstance();  
6. 　　　　　　}  
7. 　　　　　　return instance;  
8. 　　　　}  
9. 　　　　private synchronized static SingletonOptimizeLazy createInstance() {  
10. 　　　　　　if (instance == null) {  
11. 　　　　　　　　instance = new SingletonOptimizeLazy();  
12. 　　　　　　}  
13. 　　　　　　return instance;  
14. 　　　　}  
15. }  

以上这种解决方式 主要思想是将实例化的过程抽象出来 放在一个sychronized方法中执行 这样也能够实现懒加载与并发安全

不过仍然推荐使用内部类的解决方案