设计模式--单例模式的几种实现方式

最新推荐文章于 2020-01-06 21:40:20 发布

Snail_Dawn

最新推荐文章于 2020-01-06 21:40:20 发布

阅读量1k

点赞数

分类专栏：设计模式文章标签：设计模式单例模式多线程

本文链接：https://blog.csdn.net/Sun_flower77/article/details/78966091

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1. 概述

单例模式：简单的说就是可以确保只产生一个类实例，让多个用户或者多个线程同时使用这一个实例，而不需要每次使用都创建一次对象。

2. 优缺点和适用场景

单例模式节省了创建对象所需的时间，节约了系统资源，减轻了GC压力。
大部分的单例类的构造器是私有的，这就意味着单例类不容易扩展。
网上说单例的缺点还有就是长时间不使用，会被GC回收，导致对象状态的丢失，其实我不是很认同这点，我觉得单例是不会被GC回收的，毕竟是static类型的，而且始终指向着引用。这个以后具体查一查hotspot的有关实现
适用于需要频繁实例化然后销毁的类或者那些重量级对象，一次创建需要消耗很多系统资源。但是不适用于要保存状态的类，比如：一个订单类，用户A和用户B都有一条订单，A先从数据库中查出订单状态为已付款，这时订单类的状态就变成已付款了，然后B从数据库查出自己的订单状态是未付款的，如果这个订单类是单例的，那么A的订单状态也会变为未付款的，这就乱套了。
单例在多线程的场景中使用要格外小心，包括单例的创建以及共享资源的使用问题。

3. 几种不同形式的单例模式

饿汉式

class SingleClass{

    private static SingleClass instance = new SingleClass();

    private SingleClass() {
        System.out.println("single");
    }

    public static SingleClass getInstance() {
        return instance;
    }
}

这种单例的实现方式非常简单而且可靠，不会涉及到在创建单例时的非线程安全问题，因为实例的创建是在类加载时完成的。但是当这种单例不光要承担创建实例的角色，又要完成其他工作的时候，就有点不那么得心应手了，比如：

class SingleClass{

    private static SingleClass instance = new SingleClass();

    private SingleClass() {
        System.out.println("single");
    }

    public static SingleClass getInstance() {
        return instance;
    }

    public static void doSomething(){
        ...
    }
}

可以看到，这个单例不光要扮演创建实例的角色又要扮演其他角色（doSomething），当我们调用SingleClass.doSomething()的时候，如果这时类实例还没创建或者说类还没加载，虚拟机在这种场景下就会为我们加载类，并创建实例，然而我们这时并不想让SingleClass产生实例，因为还不需要用到SingleClass的实例。那么有没有一种方式可以延迟加载单例呢，让单例的创建能受我们控制，想让他什么时候创建就什么时候创建，而不是类一加载就创建实例。

懒汉式

class LazySingleClass{

    private static LazySingleClass instance = null;

    private LazySingleClass() {
        System.out.println("LazySingleClass");
    }

    public static synchronized LazySingleClass getInstance() {

        if( instance == null) {
            instance = new LazySingleClass();
        }
        return instance;
    }

    public static void doSomething(){
        ...
    }
}

当我们调用LazySingleClass.doSomething时，尽管虚拟机会加载类，但是不会创建类实例，因为我们把创建类实例的控制权完全交给了getInstance方法，只有我们调用getInstance时才会创建实例。虽然解决了延迟加载的问题，但是可以看到getInstance方法是加上了同步锁的，因为类实例不是在类加载时完成的，所以肯定涉及到非线程安全问题，当两个线程调用getInstance方法，如果不加上synchronized，一个线程创建完实例前，另一个线程判断instance是空的，这样很容易就创建了两个实例。

getInstance整个方法被加上了同步关键字，这样的效率是很低的，我们可以改良一下，把同步关键字就加在涉及线程安全问题的代码上

DCL

class LazySingleClass2{

    //这里volatile很重要
    private volatile static LazySingleClass2 instance = null;

    private LazySingleClass2() {
        System.out.println("LazySingleClass2");
    }

    public static LazySingleClass2 getInstance() {

        if( instance == null) {
            synchronized(LazySingleClass2.class){
                if( instance == null) {
                    instance = new LazySingleClass2();
                }
            }
        }
        return instance;
    }

    public static void doSomething(){
        System.out.println("...");
    }
}

双重检测，已经可以做到线程安全了，但要依赖JDK版本，在JDK5.0以后才适用，而且在效率上肯定是比不上饿汉式的。为了解决这个问题，还需要对单例模式进行改进。

使用内部类来实现单例


class InnerSingleClass{

    private InnerSingleClass() {
        System.out.println("InnerSingleClass");
    }

    private static class SingletonHolder{
        private static InnerSingleClass instance = new InnerSingleClass();
    }

    public static InnerSingleClass getInstance() {
        return SingletonHolder.instance;
    }

    public static void doSomething(){
        System.out.println("...");
    }
}

当外部类被加载时，内部类不会被初始化，而且将类实例的创建放在内部类加载时完成，避开了非线程安全问题。可以看到这种内部类的实现方式，既满足了延迟加载，又不涉及到非线程安全问题。

以上几种单例模式，的确在大多数情况下能够确保只产生一个实例了，但也有例外的情况，当通过反射，强行调用单例类的私有构造函数，就会产生多个实例，可以对私有构造函数进行异常检测。这种反射造成的问题是一种极端的方式，就不过多去讨论，还有一种情况就是序列化和反序列化的时候会破坏以上单例。

@Test
public void test6() throws IOException, ClassNotFoundException {

    //InnerSingleClass的代码上面有，还有就是InnerSingleClass要继承Serializable接口
    InnerSingleClass instance = InnerSingleClass.getInstance();
    InnerSingleClass instance2 = null;

    FileOutputStream fos = new FileOutputStream("single.txt");
    ObjectOutputStream oos = new ObjectOutputStream(fos);
    oos.writeObject(instance);
    oos.flush();
    oos.close();

    FileInputStream fis = new FileInputStream("single.txt");
    ObjectInputStream ois = new ObjectInputStream(fis);
    instance2 = (InnerSingleClass) ois.readObject();

    System.out.println(instance == instance2);
}

这段程序先将InnerSingleClass序列化到文件single.txt，再把它从文件反序列化为对象，序列化前的对象和反序列化的对象理应是同一个对象，然而程序输出为false，事实证明，序列化和反序列化拿到的对象不是同一个单例，那么怎么来避免这一问题发生呢

class InnerSingleClass implements Serializable{

    private InnerSingleClass() {
        System.out.println("InnerSingleClass");
    }

    private static class SingletonHolder{
        private static InnerSingleClass instance = new InnerSingleClass();
    }

    public static InnerSingleClass getInstance() {
        return SingletonHolder.instance;
    }

    public static void doSomething(){
        System.out.println("...");
    }

    //新加代码
    public Object readResolve() {
        return SingletonHolder.instance;
    }
}

在单例类中新加方法readResolve就可以了，在反序列化时会自动调用readResolve方法。然而还有一种单例模式是支持反序列化的，即不用在单例类里加上readResolve方法

枚举实现单例

enum EnumAnimal{

    INSTANCE;

    private EnumAnimal() {
        System.out.println("animal single");
    }
}

这样就实现了一个动物类单例，它能保证在反序列化后也是单例的，并且是线程安全的，而且也能保证不被反射破坏，具体可以去看反射newInstance()的源码，讲的很清楚。这种方式是不可以实现延迟加载的。

class User{

}

enum EnumSingleClass{

    INSTANCE;
    private User user = null;

    private EnumSingleClass() {
        System.out.println("EnumSingleClass");
        user = new User();
    }

    public User getInstance() {
        return user;
    }
}