设计模式之单例模式

单例模式在我们日常使用中可能接触不多,但是一提到spring,我们在日常工作中每天都是接触到单例模式,此文给了关于单例模式的8种写法,(一般为六种,这里细分了).

• 饿汉式（静态常量）
• 饿汉式（静态代码块）
• 懒汉式（线程不安全）
• 懒汉式（线程安全，同步方法）
• 懒汉式（线程安全，同步代码块）
• 双重检查锁
• 静态内部类
• 枚举

单例模式要求类能够有返回对象的一个引用（并且永远是同一个）和一个获得该实例的方法（必须是静态方法，往往使用getInstance()这个方法,实现步骤如下:
1 构造方法提供为私有方法.
2 提供一个静态方法，当我们调用这个方法时，如果类持有的引用不为空就返回这个引用.

注: 单例模式在多线程的环境下必须小心使用，如果当唯一实例尚未创建时，有两个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，从而同时各自创建了一个实例，这样就有两个实例被创建了出来，从而违反了单例模式种实例唯一的原则，解决的办法显而易见是加锁。

饿汉式（静态常量）

public class singleton(){
    private final static Singleton INSTANCE = new Singleton();
    
    //注意构造方法必须私有
    private Singleton(){}
    
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

此方法写法简单,实体类初始化时就被加载,未达到懒加载的效果,造成资源浪费.

饿汉式（静态代码块）

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

写法和上面类似,这边把创建实例的方法添加到静态块中.

懒汉式（线程不安全）

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

只能在单线程环境下使用,多线程下容易产生多例

懒汉式（线程安全，同步方法）

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

加了synchronized 关键字修饰,变为同步方法,不管实例是否为null,都有走synchronized方法,其实这个方法只有执行一次实例化就行,开销特别大.

懒汉式（线程安全，同步代码块）

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

并不能起到线程同步的作用,如果两个线程同时走到if(instance == null)代码中,还是会产生多个实例.

双重检查锁

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

方法内部使用两个if(singleton == null) 来做判断,并将实例singleton设置为volatile变量,线程安全，延迟加载，效率较高。

静态内部类

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

采用了类装载的机制来保证初始化实例时只有一个线程.这一点和饿汉式单例相似.不同的是静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。避免了线程不安全，延迟加载，效率高。

枚举

class Resource{
}

public enum SomeThing {
    INSTANCE;
    private Resource instance;
    SomeThing() {
        instance = new Resource();
    }
    public Resource getInstance() {
        return instance;
    }
}

获取资源的方式很简单，只要 SomeThing.INSTANCE.getInstance() 即可获得所要实例。
在枚举中我们明确了构造方法限制为私有，在我们访问枚举实例时会执行构造方法，同时每个枚举实例都是static final类型的，也就表明只能被实例化一次。在调用构造方法时，我们的单例被实例化。
也就是说，因为enum中的实例被保证只会被实例化一次，所以我们的INSTANCE也被保证实例化一次。