设计模式系列之单例模式（Singleton）

单例模式（Singleton Pattern)是java中最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责自己创建自己的对象，同时确保只有一个对象被创建。然后这个类提供了一种访问其唯一对象的方法，可以直接访问，不需要实力化该对象。

有以下3个特点：

1. 单例类只能有一个实例。
2. 单例类必须自己创建自己的唯一实例，所以其构造方法是私有的。
3. 单例类必须给所有其他对象提供这一实例。

那么为什么要有单例模式呢？他主要解决什么问题？
单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。主要是用来解决一个全局使用的类频繁的被创建和销毁。主要在想要控制实例数目，节省系统资源的时候。

使用场景：

1. 生产唯一的序列号。
2. WEB计数时，不用每次都刷新在数据库中加一次，用单例先缓存起来。
3. 创建一个对象需要消耗的资源过多，比如I/O与数据库连接等。

实现方法：
创建一个SingleObject类，有它的私有构造函数和本身的一个静态实例，并提供一个静态的方法供外界获取它的静态实例。
那么SingleObject应该像下面这么写：

// 单例-饿汉式
public class SingleObject {

    // 创建了一个对象
    private static SingleObject instance = new SingleObject();

    // 将构造方法私有化
    private SingleObject(){
        System.out.println("单例被创建了");
    }

    // 获取唯一可用对象
    public static SingleObject getInstance(){
        return instance;
    }
}

这时我们观察这个类的写法，思考这么几个问题：1.它能保证单例吗？线程是否安全？2.是否最大的解决了节省系统资源的目的？

1. 首先它是线程安全的，它基于classloader机制，避免了多线程的同步问题，保证在多线程环境下依旧是单例。
2. instance在类装载的时候就被实例化了，而不是在使用的时候再去实例化它，那么是否可以在需要使用它的时候再去实例化它呢？

为了节省系统资源，我们需要在需要的时候再去实例化这个单例，那么就变成了下面的写法

// 单例-懒汉式-多线程不安全
public class Singleton {  
    private static Singleton instance;  
    private Singleton (){
        System.out.println("单例被创建了");    
    }  
  
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

这么写，我们可以看到只有在调用getInstance()方法获取实例的时候，没有被创建的时候才会去创建该实例，但是这个时候，它多线程环境下，它就有变的不安全了，因为在多线程环境下if(instance == null)在判断前后的状态可能是不一样的，那么这个时候就会出现实例被实例化多个。虽然实现了lazy loading的效果，但是变的不是单例了，这是丢了西瓜捡芝麻。那么可以在这个基础上，让它变成多线程环境下安全吗？当然可以，我们给他加个锁不就安全了

// 单例-懒汉式-多线程安全
public class Singleton {  
    private static Singleton instance;  
    private Singleton (){
        System.out.println("单例被创建了");     
    }  
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

我们在获取实例的方法处加了synchronized锁，保证了多线程环境下的单例，同时实现了lazy loading的效果，在调用获取实例方法时才会去考虑创建实例。但是加了synchronized锁，会影响效率，getInstance()方法的性能会有影响。
那么能不能多线程环境下安全且能保证高效，还能通知达到lazy loading 的效果。

// 单例-DCL 双检锁（double-checked-locking）
public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){
        System.out.println("单例被创建了");     
    }  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
            if (singleton == null) {  
                singleton = new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}

这里我们看到使用了双锁机制，首先单例对象加上了 volatile，在获取实例对象的方法里又加上了synchronized锁。这种采用双锁机制，安全且在多线程环境下保持高性能。

欢迎关注我的公众号