设计模式学习3-单例模式

文章概述

讲了单例模式的定义、写法

写在前面

大家都知道，程序员可以自己new 对象，但是公序良俗法律法规要求我们只能一人new一个对象，但是有的人生来就在罗马，一出生就定了娃娃亲，有的人贫困潦倒，直到家里逼婚才new了对象。
2333开玩笑，上面说的一人一个对象就是单例模式，娃娃亲就是饿汉式，被逼婚就是懒汉式。

定义

**“通常我们可以让一个全局变量使得一个对象被访问，但它不能防 止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。[DP]” **
简单来说，就是创建一个全局唯一的对象，并通过一个getInstance()方法获取该对象，这就是单例。
单例模式分为懒汉式和饿汉式，饿汉式就是在编译时就创建，而懒汉时在要使用到的时候才创建，下面详细介绍单例模式的实现。

饿汉

在编译期间创建对象，然后每次调用的getInstance()获得该单例对象。
需要注意的是这里的构造方法是私有的，是为了防止被外部创建新的对象。

//饿汉
class Hungry_Singleton {
    private static Hungry_Singleton instance = new Hungry_Singleton();
    private Hungry_Singleton() {}
    public static Hungry_Singleton getInstance() {
        return instance;
    }
}

懒汉

简单实现

用一把锁锁住方法，在进入方法的时候判断是否创建，如果没有创建就new一个，这样就实现了单例，但是很显然，加上锁后效率明显降低。

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

双重校验锁

双冲校验锁就是大名鼎鼎的dcl
这种实现方式有两个注意

1. 为什么要判断两次？

因为如果有两个线程同时进入第一个if，一个进入，另一个等待，当进入的线程进去创建好了，第二个线程并不知道已经创建好了，还会重新new，就会出现问题。

2. 为什么要用volatile关键字修饰？

volatile能保证每次的信息都是最新的，不会从缓存中取数据（JVM优化），同时能保证不发生指令重排。
在下面的代码中，singleton在synchronized包围的块中也会被访问，有可能发生指令重排，所以加上volatile_限制。_

//双重校验
class Dcl_Singleton {
    private volatile static Dcl_Singleton singleton;
    private Dcl_Singleton() {}
    public static Dcl_Singleton getInstance() {
        if (singleton == null) {
            synchronized (Dcl_Singleton.class) {
                if (singleton == null) {
                    singleton = new Dcl_Singleton();
                }
            }
        }
        return singleton;
    }
}

静态内部类

静态内部类的特点就是，第一次访问的时候才会创建，并且只会创建一次。这就完美符合懒汉式单例的要求。

//懒汉静态内部类
class InnerClass_Singleton {
    private static class Singleton {
        private static final InnerClass_Singleton instance = new InnerClass_Singleton();
    }
    private InnerClass_Singleton() {
    }
    public static final InnerClass_Singleton getInstance() {
        return Singleton.instance;
    }
}

枚举

枚举是最优秀的单例模式，用java自带的关键字即可。也是唯一不会被反射破坏的单例模式。

class MySingleton{
}

enum EnumSingleton{
    SINGLETON;
    private  MySingleton singleton = null;
    private EnumSingleton(){
        System.out.println("before contrust");
        singleton = new MySingleton();
        System.out.println("after contrust");
    }
    public MySingleton getsingleton(){
        return singleton;
    }
}

查了好久都没查到到底是懒汉还是饿汉，首先enum内部是static final修饰的，看起来就很像饿汉式，但是测试一下发现实际上是懒汉式的，

确实是在第一次使用的时候才调用了构造方法，所以我个人认为是饿汉式的。至于为什么，以后有精力去看看源码。

反射破坏

除了枚举都会被反射破坏，所以当单例实现 Serializable 接口时，他们必须实现 readResolve 方法以避免有 2 个不同的对象。

优缺点

优点

1. 线程池、缓存、注册表、显卡对象、日志对象等都是单例的。
2. 我记得学jdbc时Connection最好只有一个，避免重复创建，不过使用ThreadLocal完成的。
3. Spring中的bean默认是单例的，能够提高性能减少实例的创建（减少垃圾回收的压力），提高获取的性能（除了第一次是创建，之后都是缓存中获取）。

缺点

访问的是同一个对象，会出现线程安全问题。

参考

https://segmentfault.com/a/1190000039245000
https://segmentfault.com/a/1190000040146574