单例模式
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
1.什么时候需要单实例模式？
整个类在系统运行过程中只允许一个对象，并且这个对象在整个系统的任何地方，都能够被随时随地的访问得到，并且所有的客户访问的都是同一个对象。
2.怎么来做呢？
三个要点：（1）你要定义一个私有化的构造函数
（2）你要定义一个私有的成员变量
（3）你要定义一个共有的get函数（所有的用户通过这个get函数都能够访问到唯一的这个单实例）
单例类只能有一个实例。
单例类必须自己创建自己的唯一实例。
单例类必须给所有其他对象提供这一实例。
1.单例模式——线程安全的饿汉模式
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton(){
}
public static Singleton getInstance(){
return instance;
}
}
在类加载的时候，就会执行实例化操作，创建单例对象，所以不会存在多线程安全问题
2.单例模式——线程安全的懒汉模式
public class Singleton {
private static Singleton instance = null;
private Singleton(){
}
//如果不加synchronized，则是线程不安全的，但是这样会锁住整个Single类对象，
//就会导致别的地方要用Singleton的时候去试一下是否被锁住了，锁住了则要等待所释放才能使用，
//所以会导致效率低下
public static synchronized Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
如果这个时候有多个线程访问这个实例，这个时候实例还不存在，还在new，就会进入到方法中，有多少线程就会new出多少个实例。
一个方法只能return一个实例，那最终return出哪个呢？是不是会覆盖很多new的实例？这种情况当然也可以解决，那就是加同步锁(双重锁)，避免这种情况发生 。
3.单例模式——线程安全的懒汉模式改进版（双重检查锁，线程安全）
/**
*双重锁：为了减少同步的开销
*/
public class Singleton{
//使用volatile关键字防止指令重排，确保变量的可见性
private static volatile Singleton instance = null;
// 无参构造器
private Singleton(){
}
//基于2的优化版，在方法内部加锁，这样比锁住整个类对象效率会高一些
public Singleton getInstance(){
if(instance == null){
synchronized(Singleton.class){
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}
在双检锁机制中，我们使用了synchronized关键字来创建一个锁，确保只有一个线程能进入if语句块内部。在此之前，我们首先检查instance变量是否为null。
如果为null我们才进入if语句块，获取锁，并再次检查instance变量是否为null。
这是因为在多线程环境下，可能会有多个线程同时进入第一个if语句块，如果不在此检查instance变量是否为null，
就有可能会创建多个Singleton对象，违反了单例模式的原则。
一旦我们进入了if语句块，获取了锁，就可以创建唯一的Singleton对象。
其他线程尝试进入if语句块时，由于instance变量已经不为null，所以它们不会执行if语句块内的代码，而是直接返回instance变量的值。
在整个过程中，synchronized关键字可以确保只有一个线程能够访问if一句话内的代码，在这之前和之后，instance变量由于是用volatile关键字进行了修饰，
可以被确保它在多线程环境下的可见性，从而避免了问题的发生。
4.单例模式——私有的内部类（一定线程安全）
public class One{
private One(){
}
private static class A{
private static One Instance = new One();
}
public static One getInstance(){
return A.Instance;
}
}
内部类是如何保证线程安全的呢？通过JVM虚拟机保证的，因为虚拟机加载一个class的时候只加载一次，
所以One这个类只加载一次，所以A类也只会加载一次，所以Instance只会有一个实例对象，所以可以保证单例，又可以保证线程安全
//内部类也可以换成内部接口，但是工厂类变量的作用域需为public
5.单例模式——枚举实现（一定线程安全），最优的方式，java作者推荐
public enum Singleton {
INSTANCE;
public void method(){
}
}
枚举的写法的优点：
不用考虑懒加载和线程安全的问题，代码写法简洁优雅
线程安全
反编译任何一个枚举类会发现，枚举类里的各个枚举项是是通过static代码块来定义和初始化的(可以见后面3.2节反编译分析单例枚举有分析到这个)，它们会在类被加载时完成初始化，而java类的加载由JVM保证线程安全，所以，创建一个Enum类型的枚举是线程安全的
防止破坏单例
我们知道，序列化可以将一个单例的实例对象写到磁盘，然后再反序列化读回来，从而获得一个新的实例。即使构造函数是私有的，反序列化时依然可以通过特殊的途径去创建类的一个新的实例，相当于调用该类的构造函数。
Java对枚举的序列化作了规定，在序列化时，仅将枚举对象的name属性输出到结果中，在反序列化时，就是通过java.lang.Enum的valueOf来根据名字查找对象，而不是新建一个新的对象。枚举在序列化和反序列化时，并不会调用构造方法，这就防止了反序列化导致的单例破坏的问题。
对于反射破坏单例的而言，枚举类有同样的防御措施，反射在通过newInstance创建对象时，会检查这个类是否是枚举类，如果是，会抛出异常java.lang.IllegalArgumentException: Cannot reflectively create enum objects，表示反射创建对象失败。
综上，枚举可以防止反序列化和反射破坏单例。
5.1 枚举单例模式的使用
public enum Singleton { INSTANCE; public void testMethod() { System.out.println("执行了单例类的方法"); } } // Test.java public class Test { public static void main(String[] args) { //演示如何使用枚举写法的单例类 Singleton.INSTANCE.testMethod(); System.out.println(Singleton.INSTANCE); } }
运行结果如下：
5.2 反编译分析单例枚举类
为了让大家进一步了解枚举类，我们将上面枚举单例类进行反编译javap -p Singleton.class，其中-p的意思是反编译的时候要包含私有方法。
// 这是反编译后的内容 public final class Singleton extends java.lang.Enum<Singleton> { public static final Singleton INSTANCE; private static final Singleton[] $VALUES; public static Singleton[] values(); public static Singleton valueOf(java.lang.String); private Singleton(); public void testMethod(); static {}; }
我们可以看到，
INSTANCE是Singleton类的实例
Singleton继承了java.lang.Enum类
这里还有一个私有的Singleton的无参构造方法，枚举类的枚举项都会使用这个构造方法来实例化，也就是说，这里的INSTANCE会使用这个构造方法来实例化。
实例化的过程发生在最后空的static代码块中，可以通过javap的其他参数进一步分析static里面的字节码内容，static里面其实包含了很多字节码指令，这些指令在做枚举项INSTANCE的初始化工作，而static代码块是在类加载的时候执行的，也就是说Singleton类被加载的时候，INSTANCE就被初始化了。static代码块里面除了初始化INSTANCE，Singleton[] $VALUES这个定义的私有的数组也是在static里面创建和初始化的。然后把所有枚举项按照定义的顺序放入这个$VALUES数组中，最后我们可以通过values方法来访问这个数组。
为了分析每个方法中的操作，我们使用javap -p -c -v Singleton.class来看看更详细的虚拟机执行，
-c来看每个方法中的字节码，-v把常量池信息也打印出来，重点只需要看static代码块部分的字节码
/** * @description: 重点只分析最后的static部分 */ public final class Singleton extends java.lang.Enum<Singleton> minor version: 0 major version: 52 flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER, ACC_ENUM Constant pool: // 需要注意常量池的部分，后面分析每条指令的时候可以回到这里查阅 #1 = Fieldref #4.#37 // Singleton.$VALUES:[LSingleton; #2 = Methodref #38.#39 // "[LSingleton;".clone:()Ljava/lang/Object; #3 = Class #17 // "[LSingleton;" #4 = Class #40 // Singleton #5 = Methodref #13.#41 // java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum; #6 = Methodref #13.#42 // java/lang/Enum."<init>":(Ljava/lang/String;I)V #7 = Fieldref #43.#44 // java/lang/System.out:Ljava/io/PrintStream; #8 = String #45 // 执行了单例类的方法 #9 = Methodref #46.#47 // java/io/PrintStream.println:(Ljava/lang/String;)V #10 = String #14 // INSTANCE #11 = Methodref #4.#42 // Singleton."<init>":(Ljava/lang/String;I)V #12 = Fieldref #4.#48 // Singleton.INSTANCE:LSingleton; #13 = Class #49 // java/lang/Enum #14 = Utf8 INSTANCE #15 = Utf8 LSingleton; #16 = Utf8 $VALUES #17 = Utf8 [LSingleton; #18 = Utf8 values #19 = Utf8 ()[LSingleton; #20 = Utf8 Code #21 = Utf8 LineNumberTable #22 = Utf8 valueOf #23 = Utf8 (Ljava/lang/String;)LSingleton; #24 = Utf8 LocalVariableTable #25 = Utf8 name #26 = Utf8 Ljava/lang/String; #27 = Utf8 <init> #28 = Utf8 (Ljava/lang/String;I)V #29 = Utf8 this #30 = Utf8 Signature #31 = Utf8 ()V #32 = Utf8 testMethod #33 = Utf8 <clinit> #34 = Utf8 Ljava/lang/Enum<LSingleton;>; #35 = Utf8 SourceFile #36 = Utf8 Singleton.java #37 = NameAndType #16:#17 // $VALUES:[LSingleton; #38 = Class #17 // "[LSingleton;" #39 = NameAndType #50:#51 // clone:()Ljava/lang/Object; #40 = Utf8 Singleton #41 = NameAndType #22:#52 // valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum; #42 = NameAndType #27:#28 // "<init>":(Ljava/lang/String;I)V #43 = Class #53 // java/lang/System #44 = NameAndType #54:#55 // out:Ljava/io/PrintStream; #45 = Utf8 执行了单例类的方法 #46 = Class #56 // java/io/PrintStream #47 = NameAndType #57:#58 // println:(Ljava/lang/String;)V #48 = NameAndType #14:#15 // INSTANCE:LSingleton; #49 = Utf8 java/lang/Enum #50 = Utf8 clone #51 = Utf8 ()Ljava/lang/Object; #52 = Utf8 (Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum; #53 = Utf8 java/lang/System #54 = Utf8 out #55 = Utf8 Ljava/io/PrintStream; #56 = Utf8 java/io/PrintStream #57 = Utf8 println #58 = Utf8 (Ljava/lang/String;)V { public static final Singleton INSTANCE; // 定义枚举项 descriptor: LSingleton; flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM private static final Singleton[] $VALUES; // 定义对象数组，并没有初始化，只是空引用 descriptor: [LSingleton; flags: ACC_PRIVATE, ACC_STATIC, ACC_FINAL, ACC_SYNTHETIC public static Singleton[] values(); descriptor: ()[LSingleton; flags: ACC_PUBLIC, ACC_STATIC Code: stack=1, locals=0, args_size=0 0: getstatic #1 // Field $VALUES:[LSingleton; 3: invokevirtual #2 // Method "[LSingleton;".clone:()Ljava/lang/Object; 6: checkcast #3 // class "[LSingleton;" 9: areturn LineNumberTable: line 1: 0 public static Singleton valueOf(java.lang.String); descriptor: (Ljava/lang/String;)LSingleton; flags: ACC_PUBLIC, ACC_STATIC Code: stack=2, locals=1, args_size=1 0: ldc #4 // class Singleton 2: aload_0 3: invokestatic #5 // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum; 6: checkcast #4 // class Singleton 9: areturn LineNumberTable: line 1: 0 LocalVariableTable: Start Length Slot Name Signature 0 10 0 name Ljava/lang/String; private Singleton(); descriptor: (Ljava/lang/String;I)V flags: ACC_PRIVATE Code: stack=3, locals=3, args_size=3 0: aload_0 // 栈操作指令，把局部方法表里的第0个位置的变量load加载到栈上来，a前缀表示它是一个引用类型。 // 提醒: 当JVM执行一段代码的时候，首先会把用到的所有的变量存在一个本地变量表里————局部变量表。 // 在栈上做计算的时候，需要使用局部方法表的值，就会通过load指令把它们加载到栈上来 // 在栈上运算完之后，需要把值存回到局部方法表，所以也会有对应的store指令，load和store是对应的。 1: aload_1 2: iload_2 3: invokespecial #6 // Method java/lang/Enum."<init>":(Ljava/lang/String;I)V 6: return LineNumberTable: line 1: 0 LocalVariableTable: Start Length Slot Name Signature 0 7 0 this LSingleton; Signature: #31 // ()V public void testMethod(); descriptor: ()V flags: ACC_PUBLIC Code: stack=2, locals=1, args_size=1 0: getstatic #7 // Field java/lang/System.out:Ljava/io/PrintStream; 3: ldc #8 // String 执行了单例类的方法 5: invokevirtual #9 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 8: return LineNumberTable: line 5: 0 line 6: 8 LocalVariableTable: Start Length Slot Name Signature 0 9 0 this LSingleton; static {}; descriptor: ()V. // 就是代表返回void类型 flags: ACC_STATIC Code: stack=4, locals=0, args_size=0 0: new #4 // class Singleton // new #4表示从常量池里拿到标号4这个类型的名字，往上看Constant pool部分的定义可知就是Singleton这个类，然后new出来变成对象 3: dup // 然后dup压栈 4: ldc #10 // String INSTANCE,将常量池中标号10的String类型的值INSTANCE推送到栈顶 6: iconst_0 // 定义一个int类型的变量值为0，我也不知道这里定义个常量有什么卵用 7: invokespecial #11 // Method "<init>":(Ljava/lang/String;I)V，调用构造器初始化，返回类型为void 10: putstatic #12 // Field INSTANCE:LSingleton;给INSTANCE这个静态变量赋值，和name一样 13: iconst_1 // 定义一个int类型的变量值为1，然并卵 14: anewarray #4 // class Singleton，实例化一个装Singleton枚举类型的数组，这里就是$VALUES数组 17: dup 18: iconst_0 19: getstatic #12 // Field INSTANCE:LSingleton;取出字段INSTANCE的name值 22: aastore 23: putstatic #1 // Field $VALUES:[LSingleton;将局部变量表中的枚举项的name值都依次放入$VALUES数组中 26: return LineNumberTable: line 2: 0 line 1: 13 }
5.3枚举可解决线程安全问题
上面的双重锁校验的代码之所以很臃肿，是因为大部分代码都是在保证线程安全。为了在保证线程安全和锁粒度之间做权衡，代码难免会写的复杂些。但是，这段代码还是有问题的，因为他无法解决反序列化会破坏单例的问题。
上面提到过。使用非枚举的方式实现单例，都要自己来保证线程安全，所以，这就导致其他方法必然是比较臃肿的。那么，为什么使用枚举就不需要解决线程安全问题呢？
其实，并不是使用枚举就不需要保证线程安全，只不过线程安全的保证不需要我们关心而已。也就是说，其实在“底层”还是做了线程安全方面的保证的。
那么，“底层”到底指的是什么？
这就要说到关于枚举的实现了。这里我简单说明一下：
定义枚举时使用enum和class一样，是Java中的一个关键字。就像class对应用一个Class类一样，enum也对应有一个Enum类。
通过将定义好的枚举反编译，我们就能发现，其实枚举在经过javac的编译之后，会被转换成形如public final class T extends Enum的定义。
而且，枚举中的各个枚举项同事通过static来定义的。
了解JVM的类加载机制的朋友应该对这部分比较清楚。static类型的属性会在类被加载之后被初始化，当一个Java类第一次被真正使用到的时候静态资源被初始化、Java类的加载和初始化过程都是线程安全的（因为虚拟机在加载枚举的类的时候，会使用ClassLoader的loadClass方法，而这个方法使用同步代码块保证了线程安全）。所以，创建一个enum类型是线程安全的。
也就是说，我们定义的一个枚举，在第一次被真正用到的时候，会被虚拟机加载并初始化，而这个初始化过程是线程安全的。而我们知道，解决单例的并发问题，主要解决的就是初始化过程中的线程安全问题。
所以，由于枚举的以上特性，枚举实现的单例是天生线程安全的。
枚举可避免反序列化破坏单例前面我们提到过，使用“双重校验锁”实现的单例其实是存在一定问题的，就是这种单例有可能被序列化锁破坏，关于这种破坏及解决办法，参看单例与序列化的那些事儿，这里不做更加详细的说明了。
那么，对于序列化这件事情，为什么枚举又有先天的优势了呢？答案可以在Java Object Serialization Specification 中找到答案。其中专门对枚举的序列化做了如下规定：
大概意思就是：在序列化的时候Java仅仅是将枚举对象的name属性输出到结果中，反序列化的时候则是通过java.lang.Enum的valueOf方法来根据名字查找枚举对象。同时，编译器是不允许任何对这种序列化机制的定制的，因此禁用了writeObject、readObject等方法。
普通的Java类的反序列化过程中，会通过反射调用类的默认构造函数来初始化对象。所以，即使单例中构造函数是私有的，也会被反射给破坏掉。由于反序列化后的对象是重新new出来的，所以这就破坏了单例。
但是，枚举的反序列化并不是通过反射实现的。所以，也就不会发生由于反序列化导致的单例破坏问题。
总结
在所有的单例实现方式中，枚举是一种在代码写法上最简单的方式，之所以代码十分简洁，是因为Java给我们提供了enum关键字，我们便可以很方便的声明一个枚举类型，而不需要关心其初始化过程中的线程安全问题，因为枚举类在被虚拟机加载的时候会保证线程安全的被初始化。
除此之外，在序列化方面，Java中有明确规定，枚举的序列化和反序列化是有特殊定制的。这就可以避免反序列化过程中由于反射而导致的单例被破坏问题。
