设计模式详解-单例模式详解

素颜马尾好姑娘i 2022-01-14 14:39 270阅读 0赞

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][]

在我的工作过程中，我发现所有可以使用单例模式的类都有一个共性，那就是这个类没有自己的状态，换句话说，这些类无论你实例化多少个，其实都是一样的，而且更重要的一点是，这个类如果有两个或者两个以上的实例的话，我的程序竟然会产生程序错误或者与现实相违背的逻辑错误。

这样的话，如果我们不将这个类控制成单例的结构，应用中就会存在很多一模一样的类实例，这会非常浪费系统的内存资源，而且容易导致错误甚至一定会产生错误，所以我们单例模式所期待的目标或者说使用它的目的，是为了尽可能的节约内存空间，减少无谓的GC消耗，并且使应用可以正常运作。

我稍微总结一下，一般一个类能否做成单例，最容易区别的地方就在于，这些类，在应用中如果有两个或者两个以上的实例会引起错误，又或者我换句话说，就是这些类，在整个应用中，同一时刻，有且只能有一种状态。

第一种方式，我们来看一下最标准也是最原始的单例模式的构造方式。

/**
     * @program: demo
     * @description: 单例模式
     * @author: lee
     * @create: 2018-09-20
     **/
    public class Singleton {
        private static Singleton singleton;
    
        private Singleton(){
    
        }
    
        public static Singleton getSingleton(){
            if (singleton == null) {
                singleton = new Singleton();
            }
            return singleton;
        }
    }

这是在不考虑并发访问的情况下标准的单例模式的构造方式，这种方式通过几个地方来限制了我们取到的实例是唯一的。

静态实例，带有static关键字的属性在每一个类中都是唯一的。

限制客户端随意创造实例，即私有化构造方法，此为保证单例的最重要的一步。

给一个公共的获取实例的静态方法，注意，是静态的方法，因为这个方法是在我们未获取到实例的时候就要提供给客户端调用的，所以如果是非静态的话，那就变成一个矛盾体了，因为非静态的方法必须要拥有实例才可以调用。

判断只有持有的静态实例为null时才调用构造方法创造一个实例，否则就直接返回。

**并发情况下**

当并发访问的时候，第一个调用getInstance方法的线程A，在判断完singleton是null的时候，线程A就进入了if块准备创造实例，但是同时另外一个线程B在线程A还未创造出实例之前，就又进行了singleton是否为null的判断，这时singleton依然为null，所以线程B也会进入if块去创造实例，这时问题就出来了，有两个线程都进入了if块去创造实例，结果就造成单例模式并非单例。

**改进**

/**
     * @program: demo
     * @description: 单例模式
     * @author: lee
     * @create: 2018-09-20
     **/
    public class Singleton {
        private static Singleton singleton;
        private Singleton() {}
        public synchronized static Singleton getSingleton() {
            if (singleton == null) {
                singleton = new Singleton();
            }
            return singleton;
        }
    }

上面的做法很简单，就是将整个获取实例的方法同步，这样在一个线程访问这个方法时，其它所有的线程都要处于挂起等待状态，倒是避免了刚才同步访问创造出多个实例的危险，但是我只想说，这样的设计实在是糟糕透了，这样会造成很多无谓的等待。

**双重检查**

/**
     * @program: demo
     * @description: 单例模式
     * @author: lee
     * @create: 2018-09-20
     **/
    public class Singleton {
        private static Singleton singleton;
    
        private Singleton() {
    
        }
    
        public static Singleton getSingleton() {
            if (singleton == null) {
                synchronized (Singleton.class) {
                    if (singleton == null) {
                        singleton = new Singleton();
                    }
                }
            }
            return singleton;
        }
    }

这种做法与上面那种最无脑的同步做法相比就要好很多了，因为我们只是在当前实例为null，也就是实例还未创建时才进行同步，否则就直接返回，这样就节省了很多无谓的线程等待时间，值得注意的是在同步块中，我们再次判断了synchronizedSingleton是否为null，解释下为什么要这样做。

假设我们去掉同步块中的是否为null的判断，有这样一种情况，假设A线程和B线程都在同步块外面判断了synchronizedSingleton为null，结果A线程首先获得了线程锁，进入了同步块，然后A线程会创造一个实例，此时synchronizedSingleton已经被赋予了实例，A线程退出同步块，直接返回了第一个创造的实例，此时B线程获得线程锁，也进入同步块，此时A线程其实已经创造好了实例，B线程正常情况应该直接返回的，但是因为同步块里没有判断是否为null，直接就是一条创建实例的语句，所以B线程也会创造一个实例返回，此时就造成创造了多个实例的情况。

**经过刚才的分析，貌似上述双重加锁的示例看起来是没有问题了，但如果再进一步深入考虑的话，其实仍然是有问题的。**

因为虚拟机在执行创建实例的这一步操作的时候，其实是分了好几步去进行的，也就是说创建一个新的对象并非是原子性操作。在有些JVM中上述做法是没有问题的，但是有些情况下是会造成莫名的错误。

首先要明白在JVM创建新的对象时，主要要经过三步。

**分配内存**

**初始化构造器**

**将对象指向分配的内存的地址**

这种顺序在上述双重加锁的方式是没有问题的，因为这种情况下JVM是完成了整个对象的构造才将内存的地址交给了对象。但是如果2和3步骤是相反的（2和3可能是相反的是因为JVM会针对字节码进行调优，而其中的一项调优便是调整指令的执行顺序），就会出现问题了。

因为这时将会先将内存地址赋给对象，针对上述的双重加锁，就是说先将分配好的内存地址指给singleton，然后再进行初始化构造器，这时候后面的线程去请求getSingleton方法时，会认为singleton对象已经实例化了，直接返回一个引用。如果在初始化构造器之前，这个线程使用了singleton，就会产生莫名的错误。

所以我们在语言级别无法完全避免错误的发生，我们只有将该任务交给JVM，所以有一种比较标准的单例模式。

第一种方式

/**
     * @program: demo
     * @description: 单例模式
     * @author: lee
     * @create: 2018-09-20
     **/
    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;
        }
    }

只是给静态的实例属性加上关键字volatile，标识这个属性是不需要优化的。

/**
     * @program: demo
     * @description: 单例模式
     * @author: lee
     * @create: 2018-09-20
     **/
    public class Singleton {
        private volatile static Singleton singleton;
    
        public static Singleton getInstance() {
            return InnerSingleton.singleton;
        }
    
        private static class InnerSingleton {
            protected static Singleton singleton = new Singleton();
        }
    	
    }

首先来说一下，这种方式为何会避免了上面莫名的错误，主要是因为一个类的静态属性只会在第一次加载类时初始化，这是JVM帮我们保证的，所以我们无需担心并发访问的问题。所以在初始化进行一半的时候，别的线程是无法使用的，因为JVM会帮我们强行同步这个过程。另外由于静态变量只初始化一次，所以singleton仍然是单例的。

**Singleton最多只有一个实例，在不考虑反射强行突破访问限制的情况下。**

**保证了并发访问的情况下，不会发生由于并发而产生多个实例。**

**保证了并发访问的情况下，不会由于初始化动作未完全完成而造成使用了尚未正确初始化的实例。**

--------------------

到这里你有没有疑惑，为啥不用如下这种创造方式

/**
     * @program: demo
     * @description: 单例模式
     * @author: lee
     * @create: 2018-09-20
     **/
    public class Singleton {
        private  static Singleton singleton = new Singleton();
    
        public static Singleton getInstance() {
            return singleton;
        }
    }

上述方式没有经过内部类处理，这种方式最主要的缺点就是一旦我访问了Singleton的任何其他的静态域，就会造成实例的初始化，而事实是可能我们从始至终就没有使用这个实例，造成内存的浪费。

不过在有些时候，直接初始化单例的实例也无伤大雅，对项目几乎没什么影响，比如我们在应用启动时就需要加载的配置文件等，就可以采取这种方式去保证单例。

不过值得注意的是，volatile关键字是在JDK1.5以及1.5之后才被给予了意义，所以这种方式要在JDK1.5以及1.5之后才可以使用，但仍然还是不推荐这种方式，一是因为代码相对复杂，二是因为由于JDK版本的限制有时候会有诸多不便。

转载于:https://my.oschina.net/jiansin/blog/2088216

[2019_Python_]: https://my.oschina.net/u/2663968/blog/3061697
[hot3.png]: /images/20220114/ebe11e7c23ac4d8dab9d2444dc6fe206.png