前言
在设计模式中按照不同的处理方式共包含三大类；创建型模式、结构型模式和行为模式，其中创建型模式目前已经介绍了其中的四个；工厂方法模式、抽象工厂模式、生成器模式和原型模式，除此之外还有最后一个单例模式。

单列模式介绍

单例模式可以说是整个设计中最简单的模式之一，而且这种方式即使在没有看设计模式相关资料也会常用在编码开发中。
案例场景
1：数据库的连接池不会反复创建
2：spring中一个单例模式bean的生成和使用
3：在我们平常的代码中需要设置全局的的一些属性保存

7种单例模式实现
静态类使用

package com.lm.design;import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;public class Singleton_00 {public static Map<String,String> cache = new ConcurrentHashMap<String, String>();}

以上这种方式在我们平常的业务开发中非常常见，这样静态类的方式可以在第一次运行的时候直接初始化Map类，同时这里我们也不需要到延迟加载再使用。
在不需要维持任何状态下，仅仅用于全局访问，这个使用静态类的方式更加方便。
但如果需要被继承以及需要维持一些特定状态的情况下，就适合使用单例模式。

懒汉模式(线程不安全)

package com.lm.design;public class Singleton_01 {private static Singleton_01 instance;private Singleton_01() {}public static Singleton_01 getInstance() {if (null != instance) {return instance;}return new Singleton_01();}}

单例模式有一个特点就是不允许外部直接创建，也就是new Singleton_01()，因此这里在默认的构造函数上添加了私有属性 private。
目前此种方式的单例确实满足了懒加载，但是如果有多个访问者同时去获取对象实例你可以想象成一堆人在抢厕所，就会造成多个同样的实例并存，从而没有达到单例的要求。
懒汉模式(线程安全)

package com.lm.design;public class Singleton_02 {private static Singleton_02 instance;private Singleton_02() {}public static synchronized Singleton_02 getInstance() {if (null != instance) {return instance;}return new Singleton_02();}}

饿汉模式(线程安全)

package com.lm.design;public class Singleton_03 {private static Singleton_03 instance = new Singleton_03();private Singleton_03() {}public static Singleton_03 getInstance() {return instance;}}

此种方式与我们开头的第一个实例化Map基本一致，在程序启动的时候直接运行加载，后续有外部需要使用的时候获取即可。
但此种方式并不是懒加载，也就是说无论你程序中是否用到这样的类都会在程序启动之初进行创建。
使用类的内部类(线程安全)

package com.lm.design;public class Singleton_04 {private static class SingletonHolder {private static Singleton_04 instance = new Singleton_04();}private Singleton_04() {}public static Singleton_04 getInstance() {return SingletonHolder.instance;}}

双重锁校验(线程安全)

package com.lm.design;public class Singleton_05 {private static volatile Singleton_05 instance;private Singleton_05() {}public static Singleton_05 getInstance(){if(null != instance){return instance;}synchronized (Singleton_05.class){if (null == instance){instance = new Singleton_05();}}return instance;}}

双重锁的方式是方法级锁的优化，减少了部分获取实例的耗时。
同时这种方式也满足了懒加载。
CAS「AtomicReference」(线程安全)

package com.lm.design;import java.util.concurrent.atomic.AtomicReference;public class Singleton_06 {private static final AtomicReference<Singleton_06> INSTANCE = new AtomicReference<Singleton_06>();private static Singleton_06 instance;private Singleton_06() {}public static final Singleton_06 getInstance() {for (; ; ) {Singleton_06 instance = INSTANCE.get();if (null != instance) return instance;INSTANCE.compareAndSet(null, new Singleton_06());return INSTANCE.get();}}public static void main(String[] args) {System.out.println(Singleton_06.getInstance()); // org.itstack.demo.design.Singleton_06@2b193f2dSystem.out.println(Singleton_06.getInstance()); // org.itstack.demo.design.Singleton_06@2b193f2d}}

A:java并发库提供了很多原子类来支持并发访问的数据安全性；AtomicInteger、AtomicBoolean、AtomicLong、AtomicReference。
AtomicReference 可以封装引用一个V实例，支持并发访问如上的单例方式就是使用了这样的一个特点。
B:使用CAS的好处就是不需要使用传统的加锁方式保证线程安全，而是依赖于CAS的忙等算法，依赖于底层硬件的实现，来保证线程安全。相对于其他锁的实现没有线程的切换和阻塞也就没有了额外的开销，并且可以支持较大的并发性。
C:当然CAS也有一个缺点就是忙等，如果一直没有获取到将会处于死循环中。
Effective Java作者推荐的枚举单例(线程安全)

package com.lm.design;public enum Singleton_07 {INSTANCE;public void test(){System.out.println("hi~");}}

Effective Java 作者推荐使用枚举的方式解决单例模式，此种方式可能是平时最少用到的。
这种方式解决了最主要的；线程安全、自由串行化、单一实例。
总结
1:虽然只是一个很平常的单例模式，但在各种的实现上真的可以看到java的基本功的体现，这里包括了；懒汉、饿汉、线程是否安全、静态类、内部类、加锁、串行化等等。
2:在平时的开发中如果可以确保此类是全局可用不需要做懒加载，那么直接创建并给外部调用即可。但如果是很多的类，有些需要在用户触发一定的条件后(游戏关卡)才显示，那么一定要用懒加载。线程的安全上可以按需选择。

好了 至此 设计模式之单列模式(7种单例模式案例，Effective Java 作者推荐枚举单例模式) 学习结束了 友友们 点点关注不迷路 老铁们！！！！！