Java设计模式-单例模式

一、单例模式概述

1. 定义：确保一个类只有一个实例，并提供一个全局访问点来访问这个实例

简单的说，就是你有且只有一个女朋友(有多个女朋友的模式不是这里~~)，并且你的女朋友很特殊，从来只听你的话，所以别人想和她交流(访问她)就必须通过你(全局访问点)来和她交流。

运用：系统中用到单例模式的地方很多，比如Windows系统点击开始只能出现一个开始界面，Ctrl+Alt+T， 只能出现一个资源管理器，每个进程有且对应唯一一个进程ID等等

单例模式是为了让资源得到最大化利用，不浪费资源

同时假如不采用此模式，就可能在不同时刻打开同一个界面，但界面中的内容又各不相同，因而用户极易产生误解，影响使用效率。因此单例模式在系统中的应用非常重要

2. 要点：

1）某一个单例类只能有一个实例

2）必须自行创建这个实例

3）必须向系统提供这个实例

二、单例模式的结构和实现

1. 结构：

单例模式关键要素：

1）私有的静态变量

2）私有构造函数

3）公有的静态方法

4）根据变量数判断是否生成女朋友(唯一的对象)

5）公有静态方法调用私有构造方法

关键词释义：

1）Singleton(单例)：在单例类的内部创建它的唯一实例

2）Getinstance(静态方法)：通过它产生唯一实例

3）instance(静态变量)：判断是否可以产生实例

2. 实现：

/**
 * @author ***
 * @title: Singleton
 * @projectName design-pattern
 * @description TODO
 * @date 2021/7/5 15:24
 */
public class Singleton {

   /**
    * 静态私有成员变量
    */
    private static Singleton instance = null;


    /**
     * 私有构造函数
     */
    private Singleton() {
        System.out.println("恭喜你，获得一个女朋友~~");
    }


    /**
     * 静态公有方法，返回实例
     *
     * @return
     */
    public static Singleton getInstance() {
        //没女朋友
        if (instance == null) {
            //生成一个吧
            instance = new Singleton();
        }
        //有就返回当前的，
        return instance;
    }
}

/**
 * @author ***
 * @title: Program
 * @projectName design-pattern
 * @description TODO
 * @date 2021/7/5 15:24
 */
public class Program {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        if (s1 == s2) {
            System.out.println("怎么能想要共有一个女朋友呢？S2 赶紧换一个吧...");
        }
    }
}

控制台输出：

三、饿汉式和懒汉式单例

1. 饿汉

如名字一般，就是出于很饥饿的状态，所以在定义静态变量时就实例化了单例

/**
 * @author ***
 * @title: HungryManSingleton
 * @projectName design-pattern
 * @description TODO
 * @date 2021/7/5 15:37
 */
public class HungryManSingleton {

    //静态变量实例化单例类
    private static HungryManSingleton instance = new HungryManSingleton();

    private HungryManSingleton() {
    }

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

2. 懒汉

懒汉式单例类则是在类第一次被引用时将自己实例化，单例类被加载时不会实例化，所以这很符合懒汉的气质。

但是在这里要注意的是，在定义静态变量时没有实例化单例类，而是在第一次调用静态方法时实例化单例类，这就会产生问题，高并发，多线程实现懒汉式单例时会创建多个对象，从而违背了单例模式的设计意图。

也就是还是要对女朋友的个数进行判断。这要怎么办呢？

在多线程的情况下，就要对该代码段进行控制，即每次只让一个线程进入并创建实例，也就是相当于现在的“共享女友”，帮你拍照啊，陪你去看电影啊 ，巴拉巴拉

但是，该“共享女友”有且只有一个，即单例类的唯一实例。所以，土豪们(各个线程)得一个一个租用，上一个用完了下一个才能租用。因此代码如下：

/**
 * @author ***
 * @title: LazyManSingleton
 * @projectName design-pattern
 * @description TODO
 * @date 2021/7/5 15:56
 */
public class LazyManSingleton {
    private static LazyManSingleton instance = null;
    //看做一个门
    private static final Object root = new Object();
    
    //程序运行时创建只读辅助对象
    private LazyManSingleton() {

    }

    public static LazyManSingleton getInstance() {
        //在房间外问：房间里有人吗 ？ 没人回应 ，可能没，可能下一秒有人进去 ，我却以为没人
        if (instance == null) {
            //第二次判断 
            //把门关了，外面线程进不来，只能里面的出来，外面的才能进
            synchronized (root){
                //继续问，房间里有人吗？  有就真的有，没有就真的没
                if (instance == null) {
                    //创建实例
                    instance = new LazyManSingleton();
                }
            }
        }
        return instance;
    }

}

二者比较：

1）饿汉式单例

优点：无需考虑多线程同时访问的问题，确保实例唯一性。调用速度和反应时间快于懒汉模式，因为饿汉一开始就创建，后面则直接拿来用就可以了。

缺点：不管单例对象是否需要，都会在类加载时创建，这样不如懒汉式单例，资源利用不高，且加载时间较长。如启动VS，Eclipse等，需要loading许多可能要的可能不要的，要等啊...

2）懒汉式单例

优点：第一次使用时创建，不会一直占用资源，即延迟加载。

缺点：必须考虑多线程问题，特别是单例类作为资源控制器时，会涉及资源初始化，也会耗费许多时间，也会出现多线程同时首次引用此类，造成拥堵，导致系能性能降低

四、单例模式的优缺点和适用环境

1.  单例模式的优点

1）提供唯一实例的受控访问，可以严格控制何时访问

2）由于只存在一个对象，可以节省系统资源

3）如果将单例模式的实例数目变为可变，即将单例模式进行扩展，即可获得指定数目的实例对象，即节省资源，又提高效率(相当于多例类)

2. 单例模式的缺点

1）没有抽象层，扩展有较大困难

2）单例类职责过重，一定程度上违背了单一职责原则(单例类即提供业务方法，又提供了创建对象的方法(工厂方法)，对象创建和对象本身耦合在了一起)

3）C#、JAVA 拥有GC(自动垃圾回收机制) (可以去了解下) ，在实例化的对象长时间不被利用，会被误认为垃圾进行自动销毁，下次利用又要重新创建，导致共享的单例对象丢失(女朋友丢了可不好受啊..)

3. 单例模式的适用环境

1）在系统只要一个实例对象(man只要一个girlfriend)/(资源管理器).....

2）客户调用类的单个实例只允许使用一个公共访问点，除了该点外，不允许其他途径来访问实例

五、其他写法

1.  饿汉式代码

/**
 * @author ***
 * @title: SingletonDemo1
 * @projectName design-pattern
 * @description 单例模式：饿汉式
 * @date 2021/7/5 16:41
 */
public class SingletonDemo1 {
    //类初始化立即加载，由于类加载时完成初始化，线程安全。不用同步快，调用效率高。
    private static SingletonDemo1 instance = new SingletonDemo1();

    private SingletonDemo1() {

    }

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

2. 懒汉式 同步方法

/**
 * @author ***
 * @title: SingletonDemo2
 * @projectName design-pattern
 * @description 单例模式：懒汉式线程安全
 * @date 2021/7/5 16:42
 */
public class SingletonDemo2 {

        //类初始化延迟加载，方法同步线程安全，调用效率低。
        private static SingletonDemo2 instance = null;

        private SingletonDemo2() {
        }

        public static synchronized SingletonDemo2 getInstance() {

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

3. 懒汉式 同步方法

/**
 * @author ***
 * @title: SingletonDemo3
 * @projectName design-pattern
 * @description 单例模式：懒汉式双重检查锁
 * @date 2021/7/5 16:44
 */
public class SingletonDemo3 {
    //由于编译器优化和JVM内部模型原因，同步块会有问题，会出现问题
    private static SingletonDemo3 instance = null;

    private SingletonDemo3() {

    }

    public static SingletonDemo3 getInstance() {

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

        }
        return instance;
    }
}

4 .静态内部类

/**
 * @author ***
 * @title: SingletonDemo4
 * @projectName design-pattern
 * @description 单例模式：静态内部类懒加载
 * @date 2021/7/5 16:45
 */
public class SingletonDemo4 {
    //外部没有static属性，不会立即加载对象
    //真正调用getInstance，才会加载内部类
    //高效+安全+延迟加载
    private static class SingletonInstance {
        public static SingletonDemo4 instance = new SingletonDemo4();
    }

    private SingletonDemo4() {

    }

    public static SingletonDemo4 getInstance() {
        return SingletonInstance.instance;
    }
}

5.  枚举类

/**
 * @author ***
 * @title: SingletonDemo4
 * @projectName design-pattern
 * @description 单例模式：枚举类
 * @date 2021/7/5 16:45
 */
public enum SingletonDemo5 {
    //直接用SingletonDemo06.INSTANCE本身代理，代表一个对象
    //避免反射、反序列化，效率高
    //没有懒加载
    INSTANCE;
    Enum ss;
}

6. 枚举类实现懒加载

/**
 * @author ***
 * @title: SingletonDemo6
 * @projectName design-pattern
 * @description  单例模式：枚举类实现懒加载
 * @date 2021/7/5 16:49
 */
public class SingletonDemo6 {
    // 私有构造函数
    private SingletonDemo6() {

    }

    public static SingletonDemo6 getInstance() {
        return Singleton.INSTANCE.getInstance();
    }

    private enum Singleton {
        INSTANCE;

        private SingletonDemo6 singleton;

        // JVM保证这个方法绝对只调用一次
        Singleton() {
            singleton = new SingletonDemo6();
        }

        public SingletonDemo6 getInstance() {
            return singleton;
        }
    }
}

7. 解决反射漏铜和序列化漏铜

/**
 * @author ***
 * @title: SingletonDemo7
 * @projectName design-pattern
 * @description 单例模式：解决反射漏铜，通过设置constructor.setAccessible(true);//跳过权限校验，是的创建实例不一致
 *              解决序列化漏铜，readResolve()
 * @date 2021/7/5 16:51
 */
public class SingletonDemo7 {

    //类初始化延迟加载，方法同步线程安全，调用效率低。
    private static SingletonDemo7 instance = null;

    private SingletonDemo7() {
        if (instance != null) {//防止通过反射破解单例
            throw new RuntimeException();
        }
    }

    public static synchronized SingletonDemo7 getInstance() {

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

    //反序列化时，直接返回此对象，而不生成新对象
    private Object readResolve() throws ObjectStreamException {
        return instance;
    }
}