单例模式

单例简介：

单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

特别注意：

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。

使用场景：

某些常用类频繁的被创建和销毁，使用单例设计控制实例的数目以节省系统资源。
实现思路：
将构造函数私有化，获取实例前进行判断，有则返回，无则创建后返回

模式难点：

多线程下的实例创建冲突

代码示例

Demo（利用单例简单的打印Hello World！）:

SingleObject类

public class SingleObject {
    // 创建 SingleObject 的一个对象
    private static SingleObject instance = new SingleObject();

    // 让构造函数为 private，这样该类就不会被实例化
    private SingleObject() {
    }

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

    public void showMessage() {
        System.out.println("Hello World!");
    }
}

SingletonPatternDemo类

public class SingletonPatternDemo {
    public static void main(String[] args) {

        // 不合法的构造函数
        // 编译时错误：构造函数 SingleObject() 是不可见的
        // SingleObject object = new SingleObject();

        // 获取唯一可用的对象
        SingleObject object = SingleObject.getInstance();

        // 显示消息
        object.showMessage();
    }
}

运行结果：

Hello World!

模式图：

多线程单例的实现：

主流实现方式：

懒汉式：

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

利用synchronized进行延迟加载，保证线程安全，但也损失了性能。

饿汉式：

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

基于类加载机制提前实例化，保证了线程安全，也不会因为synchronized而降低效率，但容易产生垃圾对象。

双检锁

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;  
    }  
}  

去除getInstance()上加锁，转而放置在单例类中，保障了性能和线程安全，但实现较为复杂。

登记式/静态内部类

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

将单例类的实例化放到静态内部类中，可实现延迟加载。
将getInstance()设为static final，则保证了线程安全。

结语：

在多线程模式下，一般使用饿汉式即可，如果需要实现延迟加载，则推荐使用登记式。