设计模式之单例模式

【设计模式】——单例模式

1、定义：确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

2、单例模式有以下特点：

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

3、单例模式的优点：

• 在内存中只有一个对象，节省内存空间。
• 避免频繁的创建销毁对象，可以提高性能。
• 避免对共享资源的多重占用。
• 可以全局访问。

4、适用场景：由于单例模式的以上优点，所以是编程中用的比较多的一种设计模式。我总结了一下我所知道的适合使用单例模式的场景：

• 需要频繁实例化然后销毁的对象。
• 创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
• 有状态的工具类对象。
• 频繁访问数据库或文件的对象。
• 以及其他我没用过的所有要求只有一个对象的场景。

5、单例模式注意事项：

• 只能使用单例类提供的方法得到单例对象，不要使用反射，否则将会实例化一个新对象。
• 不要做断开单例类对象与类中静态引用的危险操作。
• 多线程使用单例使用共享资源时，注意线程安全问题。

6、常见实现：

下面让我们来一起看一下单例模式的几种常见的具体实现吧

1）、 饿汉式单例模式

public class SingletonClass {

    private static final SingletonClass instance = new SingletonClass();

    //私有构造函数
    private SingletonClass() {
    }

    public static SingletonClass getInstance() {

        return instance;
    }

}

2）、懒汉式单例模式

public class SingletonClass2 {

    private static SingletonClass2 instance = null;

    private SingletonClass2() {
    }

    private synchronized static SingletonClass2 getInstance() {
        if (instance == null) {
            instance = new SingletonClass2();
        }
        return instance;
    }
}

3）、Double-Check单例（双重检查）

public class SingletonClass3 {

    private static SingletonClass3 instance;

    private SingletonClass3() {
    }

    public static SingletonClass3 getInstance() {

        if (instance == null) {//效率问题，只有为空才进入synchronized
            synchronized (SingletonClass3.class) {
                if (instance == null) {//防止出现多个实例
                    instance = new SingletonClass3();
                }
            }
        }
        return instance;
    }
}

4）、禁止指令重排序的单例，使用volatile关键字

public class SingletonClass4 {

    private static volatile SingletonClass4 instance;

    private SingletonClass4() {
    }

    public static SingletonClass4 getInstance() {

        if (instance == null) {//效率问题，只有为空才进入synchronized
            synchronized (SingletonClass4.class) {
                if (instance == null) {//防止出现多个实例
                    instance = new SingletonClass4();
                }
            }
        }
        return instance;
    }
}

5）、 静态内部类单例（Effective Java 1）
  对于内部类SingletonHolder，它是一个饿汉式的单例实现，在SingletonHolder初始化的时候会由ClassLoader来保证同步，使INSTANCE是一个真·单例。同时，由于SingletonHolder是一个内部类，只在外部类的Singleton的getInstance()中被使用，所以它被加载的时机也就是在getInstance()方法第一次被调用的时候。 —它利用了ClassLoader来保证了同步，同时又能让开发者控制类加载的时机。从内部看是一个饿汉式的单例，但是从外部看来，又的确是懒汉式的实现。

public class SingletonClass5 {

    private static class SingletonHolder {
        private static final SingletonClass5 INSTANCE = new SingletonClass5();
    }

    private SingletonClass5() {
    }

    public static final SingletonClass5 getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

6）、单元素枚举（Effective Java 2 ）
 由于创建枚举实例的过程是线程安全的，所以这种写法也没有同步的问题。无偿地提供了序列化机制，绝对防止对此实例化。即使是在面对复杂的序列化或者反射攻击的时候。虽然这中方法还没有广泛采用，但是单元素的枚举类型已经成为实现Singleton的最佳方法。但是在需要继承的场景，它就不适用了。

public enum SingletonClass6 {
    INSTANCE;

    public void anyMethod() {
        // do something
    }
}

// 使用方法如下，
SingletonClass6.INSTANCE.anyMethod();