设计模式-单例模式

设计模式-单例模式

• 什么是单例模式

  单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例

• 单例有几种写法：

  因为单例模式需要向整个系统提供单例，所以需要用static修饰，来保证全局引用。一般单例只有五种写法懒汉，恶汉，双重校验锁，枚举和静态内部类。,其中只有懒汉模式会有线程不安全，其余基本上都是线程安全的。

第一种：懒汉（线程不安全）

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  

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

第二种：懒汉（线程安全）

懒汉有两种方式：第一种把synchronized 关键字放在方法上，实现方法级别的同步，第二中是把synchronized 关键字放在代码块上，实现对象级的同步

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

第三种：恶汉

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}  

第四种：静态内部类

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

第五种：枚举

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}  

第六种：双重校验锁

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

双重校验锁中，volatile修饰符阻止了变量访问前后的指令重排，保证了指令执行顺序！

经过volatile的修饰，当线程A执行instance = new Singleton的时候，JVM执行顺序始终保证是下面的顺序，而不会发生指令重排：

memory =allocate(); //1：分配对象的内存空间

ctorInstance(memory); //2：初始化对象

instance =memory; //3：设置instance指向刚分配的内存地址

有两个问题需要注意：

• [ ] 如果单例由不同的类装载器装入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类装载器，这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。

• [ ] 如果Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和复原。不管怎样，如果你序列化一个单例类的对象，接下来复原多个那个对象，那你就会有多个单例类的实例。

• [ ] 一般的情况下，我会使用第三种方式，只有在要明确实现lazy loading效果时才会使用第五种方式，因为他们简单易懂，而且在JVM层实现了线程安全（如果不是多个类加载器环境）