本文将给大家介绍java中设计模式——单例模式；
单例模式：保证在⼀个JVM中，该对象只有⼀个实例存在；
适⽤场景：
1、某些类创建⽐较频繁，对于⼀些⼤型的对象，这是⼀笔很⼤的系统开销。
2、省去了new操作符，降低了系统内存的使⽤频率，减轻GC压⼒。
3、有些类如交易所的核⼼交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（⽐如⼀个军队出现了多个司 令员同时指挥，肯定会乱成⼀团），所以只有使⽤单例模式，才能保证核⼼交易服务器独⽴控制整个流程。
代码：
1 public class Singleton{ 2 //持有私有静态实例，防止被引用，赋值为null，目的就是实现延迟加载 3 private static Singleton instance = null; 4 5 6 //私有构造方法，防止被实例化。 7 private Singleton(){ 8 } 9 10 //创建实例 11 public static Singleton getInstance() 12 { 13 if (instance=null){ 14 instance=new Singleton(); 15 16 } 17 return instance; 18 //如果该对象被⽤于序列化，可以保证对象在序列化前后保持⼀致 19 public Object readReaslove(){ 20 return instance; 21 } 22 23 } 24 }
分类：
1.饿汉式：类初始化时创建单例，线程安全，但占用内存空间大，适⽤于占内存⼩的场景，否则推荐使⽤懒汉式延迟加载；
public class Singleton{
private static Singleton instance = new Singleton();
//构造器私有， 外部就无法new这个对象，保证一个类中只有一个实例对象
private Singleton(){}
public static Singleton newInstance(){ return instance; } }
2.懒汉式：需要单例实例的时候再创建，需要考虑线程安全(性能不太好)
懒汉式单例如何保证线程安全呢？
通过 synchronized 关键字加锁保证线程安全， synchronized 可以添加在⽅法上⾯，也可以添加在代码块上⾯，这⾥演示添加在⽅法上⾯，存在的问题是 每⼀次调⽤ getInstance 获取实例时都需要加锁和释放锁，这样是⾮常影响性能的。
1 public class Singleton{ 2 private static Singleton instance = null;//定义一个静态变量指向自己 3 private Singleton(){}//私有化构造方法 4 public static synchronized Singleton newInstance(){//加锁, 5 if (instance == null){ 6 instance = new Singleton(); 7 } 8 } 9 return instance; 10 11 }
3.双重检验锁：假如两个线程A、B，A执⾏了if (instance == null)语句，它会认为单例对象没有创建，此时线程切到B也执⾏了同样的语句，B也认为单例对象没有创建，然后两个线程依次执⾏同步代码块，并分别创建了⼀个单例对象。
这⾥的双重检查是指两次⾮空判断，锁指的是 synchronized 加锁，为什么要进⾏双重判断，其实很简单，第⼀重判断，如果实例已经存在，那么就不再需要进⾏同步操作，⽽是直接返回这个实例，如果没有创建，才会进⼊同步块，同步块的⽬的与之前相同，⽬的是为了防⽌有多个线程同时调⽤时，导致⽣成多个实例，有了同步块，每次只能有⼀个线程调⽤访问同步块内容，当第⼀个抢到锁的调⽤获取了实例之后，这个实例就会被创建，之后的所有调⽤都不会进⼊同步块，直接在第⼀重判断就返回了单例。
关于内部的第⼆重空判断的作⽤，当多个线程⼀起到达锁位置时，进⾏锁竞争，其中⼀个线程获取锁，如果是第⼀次进⼊则为 null，会进⾏单例对象的创建，完成后释放锁，其他线程获取锁后就会被空判断拦截，直接返回已创建的单例对象。其中最关键的⼀个点就是 volatile 关键字的使⽤，关于 volatile 的详细介绍可以直接搜索 volatile 关键字即可，有很多写的⾮常好的⽂章，这⾥不做详细介绍，简单说明⼀下，双重检查锁中使⽤ volatile 的两个重要特性：可⻅性、禁⽌指令重排序
这⾥为什么要使⽤ volatile ？
这是因为 new 关键字创建对象不是原⼦操作，创建⼀个对象会经历下⾯的步骤：
1. 在堆内存开辟内存空间
2. 调⽤构造⽅法，初始化对象
3. 引⽤变量指向堆内存空间
代码：
1 public class Singleton{ 2 private static volatile Singleton instance = null; 3 private Singleton(){} 4 public static Singleton getInstance(){ 5 if (instance == null) 6 { synchronized (Singleton.class){ 7 if (instance == null){ 8 instance = new Singleton(); 9 10 } 11 } 12 } 13 return instance; 14 }
4.静态内部类：可以同时保证延迟加载和线程安全。静态内部类单例是如何实现懒加载的呢？（懒加载 ：使⽤的时候再创建对象）⾸先，我们先了解下类的加载时机。
虚拟机规范要求有且只有 5 种情况必须⽴即对类进⾏初始化（加载、验证、准备需要在此之前开始）：
1. 遇到 new 、 getstatic 、 putstatic 、 invokestatic 这 4 条字节码指令时。⽣成这 4 条指令最常⻅的 Java 代码场景是：使⽤ new 关键字实例化对象的时候、读取或设置⼀个类的静态字段（final 修饰除外，被final 修饰的静态字段是常量，已在编译期把结果放⼊常量池）的时候，以及调⽤⼀个类的静态⽅法的时候。
2. 使⽤ java.lang.reflect 包⽅法对类进⾏反射调⽤的时候。
3. 当初始化⼀个类的时候，如果发现其⽗类还没有进⾏过初始化，则需要先触发其⽗类的初始化。
4. 当虚拟机启动时，⽤户需要指定⼀个要执⾏的主类（包含 main()的那个类），虚拟机会先初始化这个主类。
5. 当使⽤ JDK 1.7 的动态语⾔⽀持时，如果⼀个java.lang.invoke.MethodHandle 实例最后的解析结果是REF_getStatic 、 REF_putStatic 、 REF_invokeStatic 的⽅法句柄，则需要先触发这个⽅法句柄所对应的类的初始化。
这 5 种情况被称为是类的主动引⽤，注意，这⾥《虚拟机规范》中使⽤的限定词是 "有且仅有"，那么，除此之外的所有引⽤类都不会对类进⾏初始化，称为被动引⽤。静态内部类就属于被动引⽤的情况。当 getInstance()⽅法被调⽤时，InnerClass 才在 Singleton 的运⾏时常量池⾥，把符号引⽤替换为直接引⽤，这时静态对象 INSTANCE 也真正被创建，然后再被 getInstance()⽅法返回出去，这点同饿汉模式。那么 INSTANCE 在创建过程中⼜是如何保证线程安全的呢？在《深⼊理解 JAVA 虚拟机》中，有这么⼀句话:虚拟机会保证⼀个类的 <clinit>() ⽅法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化⼀个类，那么只会有⼀个线程去执⾏这个类的 <clinit>() ⽅法，其他线程都需要阻塞等待，直到活动线程执⾏<clinit>() ⽅法完毕。如果在⼀个类的 <clinit>() ⽅法中有耗时很⻓的操
作，就可能造成多个进程阻塞(需要注意的是，其他线程虽然会被阻塞，但如果执⾏ <clinit>() ⽅法后，其他线程唤醒之后不会再次进⼊ <clinit>() ⽅法。同⼀个加载器下，⼀个类型只会初始化⼀次。)，在实际应⽤中，这种阻塞往往是很隐蔽的。
从上⾯的分析可以看出 INSTANCE 在创建过程中是线程安全的，所以说静态内部类形式的单例可保证线程安全，也能保证单例的唯⼀性，同时也延迟了单例的实例化。
1 public class Singleton{ 2 private Singleton(){}//私有化构造方法 3 public static Singleton getInstance(){//对外提供获取实例的公共方法 4 return InnerClass.Instance;} 5 private static class InnerClass{//定义静态内部类 6 private final static Singleton Instance=new Singleton; 7 8 } 9 10 }
5.枚举：
使⽤枚举除了线程安全和防⽌反射调⽤构造器之外，还提供了⾃动序列化机制，防⽌反序列化的时候创建新的对象。
1 public enum Singleton{ 2 instance; 3 public void whateverMethod(){} 4 }
