【设计模式】单例模式

单例模式

概念以及应用特点

单例模式在代码设计中并不罕见，在设计模式的分类中，属于创建型模式(对象实例化的模式，创建型模型用于解耦对象的实例化过程)，其核心理念是某个类只能有一个实例化对象，提供一个全局的访问点。

确保只有一个实例这个概念还是比较容易理解的，例如经常在此被举例的打印机，每台计算机可以连接上若干台打印机，但是计算机中只能有一个输出打印程序，这样才能防止一份文件被多次输出到打印机上去。当然在代码中的话，这一模式经常被使用在线程池、日志模块这一环境下。其使用场景主要有以下

• 需要频繁的进行创建和销毁的对象；
• 创建对象时耗时/耗资源，但又经常使用的对象；
• 特殊工具类对象，例如日志对象；
• 频繁访问数据库或文件的对象；

单例模式的实现

单例模式要求能够有一个返回对象(永远是同一个)和一个获得该实例的方法(必须是静态方法，通常使用 getInstance 这个名称)。

单例的实现主要通过以下步骤：

1. 将该类的构造方法定义为私有方法，这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。
2. 在该类内提供一个静态方法，当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空，就创建该类的实例并将实例的引用赋予该类保持的引用。

首先演示一下单例模式的实现

public class Singleton {
    
    private static Singleton UNIQUEINSTANCE = null;
    
    private Singleton() {
        // 以防止外部直接实例化对象
    }
    
    public static Singleton getInstance() {
        if (UNIQUEINSTANCE == null) {
            UNIQUEINSTANCE = new Singleton()
        }
        return UNIQUEINSTANCE;
    }
    
}

Singleton 通过将构造方法限定为 private 避免了类在外部被实例化，在同一个 JVM 的范围内，Singleton 的唯一实例只能通过 getInstance 方法调用(在这里先不考虑反射机制)。

这种实现方式称之"懒汉式"，起到了 Lazy Loading 的效果。 不过以上实现方式并不提倡，因为在这里没有考虑到线程安全的问题。毕竟在多线程的环境下，每个线程访问单例对象方法与数据的时间，可能就只有毫厘之差，若是两个线程同时访问到没有实例化对象的静态方法，那么就会创建两个实例，这点就违反了单例模式的原则了。

考虑多线程间的协作

饿汉式(静态常量)[可用]

public class Singleton {
    
    private final static Singleton UNIQUEINSTANCE = new Singleton();
    
    private Singleton() {}
    
    public static Singlton getInstance() {
        return UNIQUEINSTANCE;
    }
    
}

• 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
• 缺点：在类装载的时候就完成了实例化，没有达到 Lazy Loading 的效果。如果从始至终都没有使用这个实例的话，会造成内存浪费。

饿汉式(静态代码块)[可用]

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

这种实现方式和上面区别不大，优缺点同上。

懒汉式(线程安全，同步方法)[不推荐用]

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

解决了一开始那种实现方式的线程不安全问题，对 getInstance 进行了线程同步。

• 缺点：效率过低，每个线程想获得类的实例的时候，执行 getInstance 方法都要进行线程同步。但是这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低要改进。

懒汉式(线程不安全，同步代码块)[不可用]

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

由于上一种方式的实现效率太低，所以摒弃同步方法，改为同步产生实例化的代码块。但是这种同步并不能起到线程同步的作用。假如一个线程进入了 if (singleton == 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;
    }
    
}

Double-check 概念对与多线程开发者来说并不陌生，如代码中所示，进行了两次 singleton == null 的检测，这样就可以保证线程安全了。这样，实例化代码只需要执行一次，后面再次访问时，判断 singleton == null 就可以直接 return 实例化对象。

• 优点： 线程安全；延迟加载；效率较高；

静态内部类[推荐用]

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

这种方式跟饿汉式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化时只有一个线程。不同的是饿汉式采用的方式是只要 Singleton 类被装载就会实例化，没有 Lazy-Loading 的作用，而静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。

类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

• 优点： 避免了线程不安全，延迟加载，效率高。

枚举

public enum Singleton {
    INSTANCE;
    public void whateverMehod(){
        
    }
}

借助枚举类来实现单例模式。不仅能避免线程同步问题，而且还能防止反序列化重新创建新的对象。

单例的劣势

单例模式常常会引入一些耦合。应该减少运用单例模式的类的数量，最好的方式是，类只需要了解与它协作的对象，却不必了解创建它所需要的限制。注意：倘若需要为测试提供子类或不同版本，由于单例只能拥有一个实例，因此它可能不是最佳选择。

小结

单例模式保证了类仅有一个实例，并为其提供了一个全局访问点。通过延迟初始化(仅在第一次使用它时才初始化)，一个单例对象是达到此目的的通用做法。

在多线程环境下，必须谨慎使用，如果当唯一实例尚未创建，有两个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，创建了两个实例，从而违法了单例模式中实例唯一的原则。解决这个问题的办法是为指示类是否已经实例化的变量提供一个互斥锁(虽然这样会降低效率)。

对象具有唯一性，并不意为使用了单例模式。单例模式通过隐藏构造函数，提供对象创建的唯一入口点，从而将类的职责集中在类的单个实例中。

参考博客 https://funtl.com/