单例设计模式

单例模式

视频来源 单例设计模式 22-33

单例模式介绍

所谓类的单例设计模式，就是采用一定的方法保证在整个的软件系统中，对某个类只能实例化一次，并且该类只会提供一个取得该对象的一个静态方法

单例模式概述

单例模式(singleton Pattern)是java最简单的设计模式之一。这种模式属于创建型模式，它提供了一种创建对象的最佳方式

单例模式的结构

单例模式的主要使用角色:

• 单例类：只能创建一个实例的类（提供者）
• 使用类：去获取单例类中的实例（使用者）

单例模式的实现

单例设计模式分类为两种：

• 饿汉式：类加载就会导致该实例对象被创建（造成性能消耗的问题）
• 懒汉式：类加载的时候不会创建改实例，只能在需要的时候才回去创建（造成多线程不安全的问题）

单例模式实现方式

1. 饿汉式(静态常量)
2. 饿汉式(静态代码块)
3. 懒汉式(线程不安全)
4. 懒汉式（线程安全，同步方法）
5. 懒汉式（线程安全，同步代码块）
6. 懒汉式（双重检查）
7. 静态内部类
8. 枚举

饿汉式（静态常量）

步骤：

1. 构造器私有化(防止外部创建对象)
2. 创建静态变量
3. 类的内部进行创建对象
4. 向外部暴露一个静态的公共的方法

public class Demo01 {
    /**
     * 私有化构造器
     */
    private Demo01(){};
    //静态常量
    private final static Demo01 instance = new Demo01();
    //提供一个公有的静态方法，返回一个实例对象
    public static Demo01 getInstance() {
        return instance;
    }
    public static void main(String[] args) {
        Demo01 instanceOne = Demo01.getInstance();
        Demo01 instanceTwo = Demo01.getInstance();
        System.out.println(instanceOne == instanceTwo); //返回结果为true
    }
}

静态常量的优点：

优点:

1. 这种写法比较简单，就是在类初始化的时候完成实例化。避免了线程安全问题。

缺点:

1. 对象随着类的加载而加载，如果该对象很大，一直没用使用会造成内存的浪费。

饿汉式（静态代码块）

public class Demo02 {
    /**
     * 私有化构造器
     */
    private Demo02(){};
    //静态常量
    private static Demo02 instance;
    //静态代码块
    static {
        instance = new Demo02();
    }
    //提供一个公有的静态方法，返回一个实例对象
    public static Demo02 getInstance() {
        return instance;
    }
    public static void main(String[] args) {
        Demo02 instanceOne = Demo02.getInstance();
        Demo02 instanceTwo = Demo02.getInstance();
        System.out.println(instanceOne == instanceTwo); //返回结果为true
    }
}

该方式很上面方式其实类似，只不过将实例化的过程放在了静态代码块中，也是在加载的时候，就执行静态代码块中的代码，初始化类的实例。所以该方式也存在内存浪费问题。

懒汉式(线程不安全)

public class Demo03 {
    /**
     * 私有化构造器
     */
    private Demo03(){};
    //静态常量
    private static Demo03 instance;
    //提供一个公有的静态方法，返回一个实例对象
    //当使用到该方法时，才会创建实例对象
    public static Demo03 getInstance()
    {
        if(instance == null){
            instance = new Demo03();
        }
        return instance;
    }
    public static void main(String[] args) {
        Demo03 instanceOne = Demo03.getInstance();
        Demo03 instanceTwo = Demo03.getInstance();
        System.out.println(instanceOne == instanceTwo); //返回结果为true
    }
}

优缺点：

优点：
解决了懒汉式造成的内存浪费的问题。 在调用getInstance的对象的时候才会创建实例。

缺点：
如果在多线程的情况下一个线程进入了if语句中的判断语句块，还未来得及创建实例，另一个线程也进入了if判断，便会造成多条实例的创建。

懒汉式（线程安全，同步方法）

public class Demo04 {
    /**
     * 私有化构造器
     */
    private Demo04(){};
    //静态常量
    private static Demo04 instance;
    //提供一个公有的静态方法，返回一个实例对象
    //当使用到该方法时，才会创建实例对象
    //给当前静态方法加上同步锁，这样所有的对象就是一把锁 , 线程同时调用此方法的时候会按照顺序依次调用
    public static synchronized Demo04 getInstance()
    {
        if(instance == null){
            instance = new Demo04();
        }
        return instance;
    }
    public static void main(String[] args) {
        Demo04 instanceOne = Demo04.getInstance();
        Demo04 instanceTwo = Demo04.getInstance();
        System.out.println(instanceOne == instanceTwo); //返回结果为true
    }
}

优缺点：

优点：
解决了线程不安全的问题

缺点：
效率太低了只有在对象第一次实例化的时候才会出现线程的问题，初始化完成就不需要了。后面再想获取该类的实例，直接返回就可以了。

懒汉式（线程安全，同步代码块）

public class Demo05 {
    /**
     * 私有化构造器
     */
    private Demo05(){};
    //静态常量
    private static Demo05 instance;
    //提供一个公有的静态方法，返回一个实例对象
    //当使用到该方法时，才会创建实例对象
    public static  Demo05 getInstance()
    {
        if(instance == null){
            //锁的是当前字节码文件对象 所有调用对象只有一把锁
            synchronized (Demo05.class){
                instance = new Demo05();
            }

        }
        return instance;
    }
    public static void main(String[] args) {
        Demo05 instanceOne = Demo05.getInstance();
        Demo05 instanceTwo = Demo05.getInstance();
        System.out.println(instanceOne == instanceTwo); //返回结果为true
    }
}

优缺点：

优点:这种方式，同上一种同步方法的改进，同步方法效率太低，变成同步创建实例化对象的代码块

缺点：也会造成同步方法一样的问题创建多个实例

懒汉式（双重检查）

public class Demo06 {
    /**
     * 私有化构造器
     */
    private Demo06(){};
    //静态常量
    //添加volatile 关键字  在多线程的情况下，可能会出现空指针问题，原因是 JVM 在实例化对象的时候会进行优化和指令重排序操作。
    //volatile 关键字可以保证可见性和有序性。
    private static volatile Demo06 instance;
    //提供一个公有的静态方法，返回一个实例对象
    //当使用到该方法时，才会创建实例对象
    public static Demo06 getInstance()
    {
        if(instance == null){
            //锁的是当前字节码文件对象 所有调用对象只有一把锁
            //第一次判断如果不为null，不需要抢占锁，直接返回对象
            synchronized (Demo06.class){
            //第二次判断，抢占到锁以后再次判断
                if(instance == null){
                    instance = new Demo06();
                }
            }
        }
        return instance;
    }
    public static void main(String[] args) {
        Demo06 instanceOne = Demo06.getInstance();
        Demo06 instanceTwo = Demo06.getInstance();
        System.out.println(instanceOne == instanceTwo); //返回结果为true
    }
}

优缺点：

优点： 双重检查锁模式是一种比较的单例实现模式，解决了单例、性能、线程安全问题。进行了两次if判断避免了多次创建实例 ，在变量中使用volatile关键字避免造成空指针问题

静态内部类

静态内部类单例模式中实例是由内部类创建，由于JVM在加载外部类的过程中，是不会加载静态内部类的，只有内部类的属性/方法被调用时才会被加载，并初始化其静态属性。静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。 加载和初始化都是线程安全的。

public class Demo07 {
    //构造器私有化，外部不能new
    private Demo07(){};
    //静态内部类
    public static class SingletonInstance{
        private static final Demo07 INSTANCE = new Demo07();
    }
    public static Demo07 getInstance(){
        //调用该方法的时候，静态内部类才会加载
        return SingletonInstance.INSTANCE;
    }

    public static void main(String[] args) {
        Demo07 instanceOne = Demo07.getInstance();
        Demo07 instanceTwo = Demo07.getInstance();
        System.out.println(instanceOne == instanceTwo); //返回结果为true
    }
}

枚举

public enum Demo08 {
    //枚举常量
    SINGLETON;
    //分解为 public static final Demo08 SINGLETON = new Demo08();

    public static void main(String[] args) {
        Demo08 instanceOne = Demo08.SINGLETON;
        Demo08 instanceTwo = Demo08.SINGLETON;
        System.out.println(instanceOne == instanceTwo); //返回结果为true
    }
}

枚举方式是饿汉式单例模式，如果不考虑浪费内存空间的问题，这是极力推荐的单例实现模式。
因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式。而且还能防止反序列化重新创建新的对象。

破坏单例模式

有两种方式可以使上面定义的单例模式可以创建多个对象(枚举方式除外)，分类就是序列化和反射。

1. 第一种：类进行序列化再进行反序列化造成对象不一致。
2. 第二种：通过反射取消访问检查在通过构造器创建对象。