Java设计模式（一）------单例模式

概念：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，是一种常见的设计模式。

分类：懒汉式单例、饿汉式单例、登记式单例（可忽略）

特点：（1）只能有一个实例。

      （2）必须自己创建自己的唯一实例

      （3）必须给所有其他对象提供这一实例

一、懒汉式单例

1. //懒汉式单例类.在第一次调用的时候实例化自己   
2. public class Singleton {  
3.     private Singleton() {}  
4.     private static Singleton single=null;  
5.     //静态工厂方法   
6.     public static Singleton getInstance() {  
7.          if (single == null) {    
8.              single = new Singleton();  
9.          }    
10.         return single;  
11.     }  
12. }  

这种情况是线程不安全的，有几种方法实现：

1、在getInstance方法上加同步

1. public static synchronized Singleton getInstance() {  
2.          if (single == null) {    
3.              single = new Singleton();  
4.          }    
5.         return single;  
6. }  

2、双重检查锁定

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

3、静态内部类

1. public class Singleton {    
2.     private static class LazyHolder {    
3.        private static final Singleton INSTANCE = new Singleton();    
4.     }    
5.     private Singleton (){}    
6.     public static final Singleton getInstance() {    
7.        return LazyHolder.INSTANCE;    
8.     }    
9. }

这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。

二、饿汉式单例

1. //饿汉式单例类.在类初始化时，已经自行实例化   
2. public class Singleton1 {  
3.     private Singleton1() {}  
4.     private static final Singleton1 single = new Singleton1();  
5.     //静态工厂方法   
6.     public static Singleton1 getInstance() {  
7.         return single;  
8.     }  
9. } 

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。