单例模式（Singleton）

因程序需要，有时我们只需要某个类同时保留一个对象，不希望有更多对象，此时，我们则应考虑单例模式的设计。

单例模式的特点：

• 单例模式只能有一个实例，这是核心点，也就是为什么叫作单例模式。

• 单例类必须自己创建自己的唯一实例，构造方法私有化，只能自己创建自己。

• 单例类必须向其他对象（外部对象）提供这一实例。

懒汉模式

懒汉模式是指在使用的时候才开始创建单例类，如果单例类需要初始化很久，则在首次使用该实例时将等待初始化。如下：

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

如上，通过提供一个静态的对象instance，利用private权限的构造方法和getInstance()方法来给予访问者一个单例。

缺点是，没有考虑到线程安全，可能存在多个访问者同时访问，并同时构造了多个对象的问题。之所以叫做懒汉模式，主要是因为此种方法可以非常明显的延迟加载。

懒汉模式存在线程不安全的问题，我们自然想到了，在getInstance()方法前加锁，于是就有了第二种实现。代码如下：

// 线程安全的懒汉模式
public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){}
    public static synchronized SingletonDemo getInstance(){
        if(instance==null){
            instance=new SingletonDemo();
        }
        return instance;
    }
}

然而并发其实是一种特殊情况，大多时候这个锁占用的额外资源都浪费了，这种打补丁方式写出来的结构效率很低。

公共广告位-后端

饿汉模式

饿汉模式是指在类加载到JVM时进行初始化，不进行延迟加载。Java实例代码如下：

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

直接在运行这个类的时候进行一次加载，之后直接访问。显然，这种方法没有起到延迟加载（Lazy Loading）的效果，考虑到前面提到的和静态类的对比，这种方法只比静态类多了一个内存常驻而已。

静态类内部加载

public class SingletonDemo {
    private static class SingletonHolder{
        private static SingletonDemo instance=new SingletonDemo();
    }
    private SingletonDemo(){
        System.out.println("Singleton has loaded");
    }
    public static SingletonDemo getInstance(){
        return SingletonHolder.instance;
    }
}

使用内部类的好处是，静态内部类不会在单例加载时就加载，而是在调用getInstance()方法时才进行加载，达到了类似懒汉模式的效果，而这种方法又是线程安全的。

枚举方法

enum SingletonDemo{
    INSTANCE;
    public void otherMethods(){
        System.out.println("Something");
    }
}

Effective Java作者Josh Bloch 提倡的方式，在我看来简直是来自神的写法。解决了以下三个问题：

• 自由序列化

• 保证只有一个实例

• 线程安全

如果我们想调用它的方法时，仅需要以下操作：

public class Hello {
    public static void main(String[] args){
        SingletonDemo.INSTANCE.otherMethods();
    }
}

这种充满美感的代码真的已经终结了其他一切实现方法了。

双重校验锁法

public class SingletonDemo {
    private volatile static SingletonDemo instance;
    private SingletonDemo(){
        System.out.println("Singleton has loaded");
    }
    public static SingletonDemo getInstance(){
        if(instance==null){
            synchronized (SingletonDemo.class){
                if(instance==null){
                    instance=new SingletonDemo();
                }
            }
        }
        return instance;
    }
}

接下来我解释一下在并发时，双重校验锁法会有怎样的情景：

• STEP 1. 线程A访问getInstance()方法，因为单例还没有实例化，所以进入了锁定块。

• STEP 2. 线程B访问getInstance()方法，因为单例还没有实例化，得以访问接下来代码块，而接下来代码块已经被线程1锁定。

• STEP 3. 线程A进入下一判断，因为单例还没有实例化，所以进行单例实例化，成功实例化后退出代码块，解除锁定。

• STEP 4. 线程B进入接下来代码块，锁定线程，进入下一判断，因为已经实例化，退出代码块，解除锁定。

• STEP 5. 线程A获取到了单例实例并返回，线程B没有获取到单例并返回Null。

理论上双重校验锁法是线程安全的，并且，这种方法实现了延迟加载。