Java开发中常用的设计模式(二)---单例模式

一. 懒汉式单例

//懒汉式单例类.在第一次调用的时候实例化自己 
public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法 
    public static Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
    }
}

　　　　以上懒汉式单例是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，

　　都是对getInstance这个方法改造，保证了懒汉式单例的线程安全。

　　1. 在getInstance方法上加同步

public static synchronized Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
}

　　虽然线程安全了，但是每次都要同步，会影响性能

　　2. 双重检查锁定

public static Singleton getInstance() {
        if (singleton == null) {  
            synchronized (Singleton.class) {  
               if (singleton == null) {  
                  singleton = new Singleton(); 
               }  
            }  
        }  
        return singleton; 
}

　　也是线程安全的，同时避免了每次都同步的性能损耗

　　3. 静态内部类

public class Singleton {  
    private static class LazyHolder {  
       private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
       return LazyHolder.INSTANCE;  
    }  
}  

 　　线程安全的，同时没有性能损耗，所以一般我倾向于使用这一种

二. 饿汉式单例

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

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