单例设计模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

上面这几句引自https://www.runoob.com/design-pattern/singleton-pattern.html

众所周知，单例模式分为懒汉式和饿汉式。下面我逐一介绍。

饿汉式：

public class HungryMan {

    private HungryMan(){}

    private static final HungryMan HUNGRY_MAN = new HungryMan();

    public static HungryMan getInstance(){
        return HUNGRY_MAN;
    }

    public static void main(String[] args) {
        HungryMan hungryMan1 = HungryMan.getInstance();
        HungryMan hungryMan2 = HungryMan.getInstance();
        System.out.println(hungryMan1.hashCode());
        System.out.println(hungryMan2.hashCode());
    }
}

说明创建的是同一个对象

但是饿汉式会造成资源的浪费

懒汉式：

public class LazyMan {

    private LazyMan(){}

    public static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if(lazyMan == null){
            lazyMan = new LazyMan();
            return lazyMan;
        }
        return lazyMan;
    }

    public static void main(String[] args) {
        LazyMan lazyMan1 = LazyMan.getInstance();
        LazyMan lazyMan2 = LazyMan.getInstance();
        System.out.println(lazyMan1.hashCode());
        System.out.println(lazyMan2.hashCode());
    }
}

看到两个对象是一样的

但是多线程的情况下懒汉式是不安全的

检验不安全：

public class LazyMan {

    private LazyMan(){}

    public static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if(lazyMan == null){
            //睡一会
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lazyMan = new LazyMan();
            return lazyMan;
        }
        return lazyMan;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                LazyMan instance = LazyMan.getInstance();
                System.out.println(instance.hashCode());
            }).start();
        }
    }
}

哈希值是不一样的，所以懒汉式在并发的情况下是不安全的

加了锁的懒汉式

public class LazyMan {

    private LazyMan(){}

    public static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if(lazyMan == null){
            synchronized(LazyMan.class){
                if(lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
            return lazyMan;
        }
        return lazyMan;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                LazyMan instance = LazyMan.getInstance();
                System.out.println(instance.hashCode());
            }).start();
        }
    }
}

延迟一秒的结果（代码中没有体现）

 

线程A执行到3的位置，线程B抢到执行权，停留在1的位置，因为有锁不能继续执行，线程A创建对象，线程B即使能执行到2的位置，但是因为对象不是null，还是不能执行到3的位置，不能创建新的对象。

但是，另一个问题来了

public static LazyMan getInstance(){
    if(lazyMan == null){
        synchronized(LazyMan.class){
            if(lazyMan == null){
                lazyMan = new LazyMan();
                /**
                 * lazyMan = new LazyMan();
                 * 但是这句话并不是一个原子性的，它有三个步骤
                 * 1、开辟一段内存地址
                 * 2、执行构造函数，初始化对象
                 * 3、将对象指向这段内存地址
                 * 完美的情况下是  1 2 3 ，但是可能 万一是 1 3 2
                 * 开辟完内存地址，指向这段内存地址，初始化对象
                 * 此时的初始化对象已经无济于事，因为已经指向内存地址了
                 * 这就导致，不是原子性的问题带来的影响
                 */
            }
        }
        return lazyMan;
    }
    return lazyMan;
}

所以我们需要加上volatile

但是我们依旧可以通过反射来破坏

package com.xiaofei.single;

import java.lang.reflect.Constructor;
import java.util.concurrent.TimeUnit;

/**
 * @author xiaofei
 * @version 1.0
 * @date 2020/9/12 18:47
 */

public class LazyMan {

    private LazyMan(){}

    public volatile static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if(lazyMan == null){
            synchronized(LazyMan.class){
                if(lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
            return lazyMan;
        }
        return lazyMan;
    }

    public static void main(String[] args) throws Exception {
        LazyMan lazyMan1 = LazyMan.getInstance();
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        LazyMan lazyMan2 = constructor.newInstance();
        System.out.println(lazyMan1.hashCode());
        System.out.println(lazyMan2.hashCode());
    }
}

可以发现，反射依旧可以破坏

下面我们用到终极办法：枚举

public enum  SingleEnum {

    SINGLENUM;
}
class Test{
    public static void main(String[] args) {
        SingleEnum singlenum1 = SingleEnum.SINGLENUM;
        SingleEnum singlenum2 = SingleEnum.SINGLENUM;
        System.out.println(singlenum1.hashCode());
        System.out.println(singlenum2.hashCode());
    }
}

枚举写法简单，而且不会被反射破坏