关于java:单例模式最熟悉的陌生人

“你相熟设计模式吗？”

“我最相熟单例模式。”

你张开嘴巴，自信一吼，散发荣耀🌈

知面不知心

即便没吃过猪肉，但也见过猪跑。问起设计模式，必不可缺少的就是单例模式。

单例模式：保障一个类只有一个实例，并提供一个拜访该实例的全局节点

翻译：创立一个惟一类对象，保障内部每次应用都是这个惟一对象。

随后你又写下实现代码，来证实本人“很懂”单例，毕竟它是如此简略！

• 创立单例类

  public class SingleObject {private static SingleObject instance = new SingleObject();
    private SingleObject() {}
    public static SingleObject getInstance() {return instance;}
    public void showMessage() {System.out.println("Hello World!");
    }
  }

• static 润饰的变量会在类加载时进行创立 （记着这一点，下文会提到），并在内存中只有一份正本，应用时所有该类的实例共享同一个 static 变量。即便咱们通过 对象. 动态变量名 进行拜访，虽对象内存不同，但拜访的动态变量都是同一份，所以举荐 类名. 动态变量名 进行拜访更不便。
• 将 instance 设为 private 目标是保障内部无奈间接应用，须要 Get 办法拜访。

• 获取惟一对象并应用。

  public class SingletonDemo {public static void main(String[] args) {SingleObject object = new SingleObject();// 谬误！因为结构公有，所以编译报错
        SingleObject object = SingleObject.getInstance();// 正确
        object.showMessage();}
  }

  上述代码是咱们传统实现，也是咱们最为相熟的局部，这种实现被称之为 “ 饿汉式🍔”，之所以叫饿汉式是因为SingleObject instance = new SingleObject(); 无论咱们是否应用 instance 对象，每当 SingleObject 类加载时就会通过 new 关键字创建对象进行内存的开拓，就犹如饿怕了的人，即便吃饱了，也要把干粮屯好，避免再受饿。

看到这里是不是感觉非常离奇，最相熟的单例居然开始变得生疏了！毕竟相熟一个人从心田开始，而相熟设计模式，也要从它的 “ 心田 ” 登程。

重拾温顺的 “ 她 ”

与饿汉式相比，在类加载时不进行内存开拓，只有应用时才实例创建对象，被称之为 “ 懒汉式 ”，犹如一个人懒的感觉饿了才去吃货色。

懒汉式💤

• 线程不平安

  public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {if (instance == null) {
            // 线程问题
            instance = new Singleton();}
        return instance;
    }
  }

  传统懒汉式存在线程问题，假如有两个线程 T1 和 T2，同时执行上述代码，当 T1 走完 if (instance == null) 但没走到 instance = new Singleton();，这个时候 T2 线程比它当先一步，执行了instance = new Singleton(); 将 instance 初始化。此时 T1 线程继续执行，将 instance 又从新初始化。因而会将 instance 初始化两次，从而违反了单例模式的意义。

• 线程平安

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

  通过 synchronized 保障了线程平安，然而因为每个线程执行到 getInstance 办法时都得期待锁的开释，因而会影响性能，所以就有了 双重校验锁 模式。

  双重校验锁🔒

• 谬误双重校验锁

  public class Singleton {
    private static Singleton instance;
    private Singleton (){}
    public static Singleton getInstance() {if (instance == null) {
        // Time1
            synchronized (Singleton.class) {
            //Time2
                if (instance == null) {instance = new Singleton(); // 指令重排
                }
            }
        }
        return singleton;
    }
  }

  第一个 if 对 instance 进行判断，如果初始化实现即 !=null 则间接返回。如果 ==null 继续执行，当多个线程执行到 Time1 时会期待锁的开释，当持有锁的线程开释后，其余线程会抢锁，而后某个线程从新拿到锁继续执行，并在 Time2 处从新判断 instance 是否为空，因为之前线程曾经把 instance 初始化，所以间接返回，防止反复赋值。

然而这是现实状态，在零碎中 instance = new Singleton(); 被分为三步执行：

1. 分配内存空间
2. 初始化对象
3. 将对象指向刚调配的内存空间

然而零碎为了将性能最大化，在不影响后果的状况下，会对上述步骤从新排序，有可能是这样：

1. 分配内存空间
2. 将对象指向刚调配的内存空间
3. 初始化对象

当 T2 线程执行到 Time2 时，此时 T1 线程执行了 “ 将对象指向刚调配的内存空间 ”，还并没有初始化对象，而未被初始化的内存空间有可能是被应用过的，是有值的（具体什么值不分明），此时 T2 继续执行，拜访到初始化未实现的 instance 对象并判断 instance 不为空，之后会将未初始化对象返回，这是谬误的。❌

• 正确双重校验锁

public class Singleton {
    private volatile static Singleton instance;
    private Singleton (){}
    public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class) {if (instance == null) {singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

给予变量 volatile 关键字，而 volatile 作用就是禁止指令重排，因而很好的防止了上述情况。

下面太简单？别急，接下来介绍用更简略的办法实现双重校验锁的性能👇。

动态外部类🌳

public class Singleton {
    private static class SingletonHolder {private static final Singleton instacne = new Singleton();
    }
    private Singleton (){}
    public static final Singleton getInstance() {return SingletonHolder.instacne;}
}

你是否还记得我下面让你记住的一句话：”static 润饰的变量会在类加载时进行创立 ”，而通过动态外部类，即便里面一层 Singleton 类被加载，但只有咱们外部 SingletonHolder 类没有被动应用，那么 instance 就不被初始化。当调用 getInstance 办法如 StaticSingleton staticSingleton = StaticSingleton.getInstance(); 才会加载 SingletonHolder 类，实例化 instance，防止内存节约。

文中代码来自菜鸟教程，作者略作改变！

我是 Haoo，一个乐观的码农，撰写乏味的文章。
如果这篇文章帮忙到你，请珍藏⭐点赞👍加关注👀，跟踪不迷路(🌻◡‿◡)