单例模式（Singleton）
Singleton模式，主要是一般为了保证自己研发的系统或者软件中只有一个实例，如果使用 Java 的理解就是只有一个对象。因为对象是可以通过 new 的方式来创建，所以为了保证我们的系统里面只有一个对象，必须要做一些约定，然后这些约定和实现，可以称之为单例模式。
在这里，我说个我年轻粗浅理解的一个笑话，我看到单例模式？以为无论如何使用都是单例的，所以我在构思一个软件的时候，想着在另外一个Java应用中，直接调用另外一个Java应用中的单例对象，试图操作另外一个应用。经过几次尝试，我发现不管我怎么设置，另外一个应用就是对我的设置不做任何响应，那时候我觉得委屈极了，怎么就不对呢？现在想想真是一个愚蠢的笑话，当时就没弄明白应用（也可理解为Windows里面的进程）之间是隔离的、独立的，如果想获得另外一个应用的对象，必须通过通信或者文件共享。我说这个笑话主要是想告诉你：假如你也闹了一些类似的笑话，没关系，因为，很多人也闹过。如果你不想再闹这些笑话，只能学习。
单例模式的实现有很多种方式，下面我简单介绍一些常用的写法。
饿汉式
这个模式的好处就是简单、方便，也便于理解，唯一实例是依靠 JVM 来实现。主要的开发源码如下：
/**
* 饿汉式
* 类加载到内存以后，直接new一个单例，由JVM保证线程的安全
* 简单实用
*
* 问题：无论用到与否，类都需要装载。
*/
public class Mgr01 {
private static final Mgr01 INSTANCE = new Mgr01();
private Mgr01() {}
public static Mgr01 getInstance() {
return INSTANCE;
}
public void out() {
System.out.println("this is Mgr01");
}
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new Thread(()->{
Mgr03 mgr03 = Mgr03.getInstance();
//我们输出线程的hash值，假如是同一个对象，hash值肯定一样。
System.out.println(mgr03.hashCode());
}).start();
}
}
}
懒汉式
从上面的用例我们可以明显的看到，饿汉式的核心问题，与java的核心 LazyLoading（懒加载）理念不一样，众所周知 Java 是懒加载的，跑性能前，一般都建议先跑30分钟预热，因为java是越跑越快（这个原理，请翻阅JVM相关资料）。所以有人说第一个方式不合理。又提出了LazyLoading 的方案。
/**
* lazy loading
* 懒汉式加载
* 虽然达到了懒加载的目的，但是带来了线程不安全的问题
*/
public class Mgr03 {
private static Mgr03 INSTANCE;
private Mgr03() {}
public static Mgr03 getInstance(){
if (null == INSTANCE) {
//假如这里阻塞了，或者
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr03();
}
return INSTANCE;
}
public void out () {
System.out.println("this is Mgr03");
}
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new Thread(()->{
Mgr03 mgr03 = Mgr03.getInstance();
//我们输出线程的hash值，假如是同一个对象，hash值肯定一样。
System.out.println(mgr03.hashCode());
}).start();
}
}
}
双重判空加锁
前面写的 LazyLoading 加载方案，明显存在并发问题，如果并发上来以后，对象可能就不是同一个，所以提出了加锁 synchronized 的方式。如果把 synchronized 加到方法上，固然能解决问题，但是肯定会带来性能问题。所以专家提议把锁加到判断空以后的方法块上面，所以有了双重判空的方式。就有如下代码。
/**
* lazy loading
* 懒汉式加载
* 虽然达到了懒加载的目的，但是带来了线程不安全的问题
*
* 双重判空加锁
*/
public class Mgr06 {
private static Mgr06 INSTANCE;
private Mgr06() {}
public static Mgr06 getInstance(){
if (null == INSTANCE) {
synchronized (Mgr06.class){
if (null == INSTANCE) {
//假如这里阻塞了，或者
try {
Thread.sleep(2100);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr06();
}
}
}
return INSTANCE;
}
public void out () {
System.out.println("this is Mgr03");
}
public static void main(String[] args) {
System.out.println("Thread start ..........");
for (int i = 0; i < 20; i++) {
new Thread(()->{
Mgr06 mgr03 = Mgr06.getInstance();
//我们输出线程的hash值，假如是同一个对象，hash值肯定一样。
System.out.println(mgr03.hashCode());
}).start();
}
}
}
静态内部类
这个方式，其实之前我是没接触过的，看完这种方式以后，觉得这个操作真是骚，比双重判空感觉优雅多了。这个方式，其实是利用了Java静态内部类（也是依靠JVM来保证）。因为JVM在加载Java类时，如果没有用到是不会创建静态的内部类。这样又达到了 LazyLoading 的目的，又避免了加锁。加锁一般情况下是不建议加锁的，加锁会浪费系统资源。
/**
* lazy loading
* 懒汉式加载
*
* 静态内部类的方法
* JVM保证单例
* 加载外部类时，不会加载到内部类，这样可以实现懒加载
*/
public class Mgr07 {
private Mgr07() {}
private static class Mgr07Holder {
private final static Mgr07 INSTANCE = new Mgr07();
}
public static Mgr07 getInstance(){
//假如这里阻塞了，或者
try {
Thread.sleep(2100);
} catch (InterruptedException e) {
e.printStackTrace();
}
return Mgr07Holder.INSTANCE;
}
public void out () {
System.out.println("this is Mgr03");
}
public static void main(String[] args) {
System.out.println("Thread start ..........");
for (int i = 0; i < 20; i++) {
new Thread(()->{
Mgr07 mgr07 = Mgr07.getInstance();
//我们输出线程的hash值，假如是同一个对象，hash值肯定一样。
System.out.println(mgr07.hashCode());
}).start();
}
}
}
枚举单例
面对网络上面的众多关于单例的讨论和方式，让我们的Java创始人之一的某位大神也产生了兴趣，最后终极大招，枚举单例。这种模式可以防止反序列号，大哥出手，一看就有。具体的写法如下。
/**
*
* java创始人之一 ，写个了更完美的，这种写法，可以防止反序列化
* 枚举单例
*/
public enum Mgr08 {
INSTANCE;
public void out () {
System.out.println("this is Mgr03");
}
public static void main(String[] args) {
System.out.println("Thread start ..........");
for (int i = 0; i < 20; i++) {
new Thread(()->{
//我们输出线程的hash值，假如是同一个对象，hash值肯定一样。
System.out.println(Mgr08.INSTANCE.hashCode());
}).start();
}
}
}
最后，单例模式使用范围非常广，几乎所有的开源产品都使用了单例模式，例如一个数据库连接池、一个线程池、读取配置文件等等，Spring 的 IOC 容器里面，默认的对象，都是单例的。所以单例这种设计模式，一定要充分的理解和掌握。
