Java中单例(Singleton)模式是一种广泛使用的设计模式。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。
单例模式好处:
1.它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间；
2.能够避免由于操作多个实例导致的逻辑错误。
3.如果一个对象有可能贯穿整个应用程序，而且起到了全局统一管理控制的作用，那么单例模式也许是一个值得考虑的选择。
饿汉式
public class Hungry {
private Hungry(){} //构造函数
private final static Hungry HUNGRY=new Hungry();//自己创建实例
// 通过该函数向整个系统提供实例
public static Hungry getInstance(){
return HUNGRY;
}
}
从代码中我们看到，类的构造函数定义为private的，保证其他类不能实例化此类，然后提供了一个静态实例并返回给调用者。饿汉模式是最简单的一种实现方式，饿汉模式在类加载的时候就对实例进行创建，实例在整个程序周期都存在。
- 它的好处是只在类加载的时候创建一次实例，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题。
- 它的缺点也很明显，即使这个单例没有用到也会被创建，而且在类加载之后就被创建，内存就被浪费了。
- 这种实现方式适合单例占用内存比较小，在初始化时就会被用到的情况。但是，如果单例占用的内存比较大，或单例只是在某个特定场景下才会用到，使用饿汉模式就不合适了，这时候就需要用到懒汉模式进行延迟加载。
懒汉式
//懒汉式
public class Lazyman {
private Lazyman(){}//构造函数
private static Lazyman lazyman;//不实例化
//通过该函数向整个系统提供实例
public static Lazyman getInstance(){
// 当 lazyman 为 null 时，则实例化对象，否则直接返回对象
if(lazyman==null){
lazyman =new Lazyman();//实例化
}
return lazyman;//返回已经存在的对象
}
- 好处：懒汉模式中单例是在需要的时候才去创建的，如果单例已经创建，再次调用获取接口将不会重新创建新的对象，而是直接返回之前创建的对象。
- 适用于：如果某个单例使用的次数少，并且创建单例消耗的资源较多，那么就需要实现单例的按需创建，这个时候使用懒汉模式就是一个不错的选择。
- 缺点：但是这里的懒汉模式并没有考虑线程安全问题，在多个线程可能会并发调用它的getInstance()方法，导致创建多个实例，因此需要加锁解决线程同步问题，实现如下:
当线程 A 进入到 if 判断条件后，开始实例化对象，此时 lazyman 依然为 null；又有线程 B 进入到 if 判断条件中，之后也会通过条件判断，进入到方法里面创建一个实例对象。
所以我们需要对该方法进行加锁，保证多线程情况下仅创建一个实例。这里我们使用 Synchronized 同步锁来修饰 getInstance2 方法：
// 懒汉模式 + synchronized 同步锁
//加了synchronized锁适用多线程，但效率不高
private Lazyman(){}
private static Lazyman lazyman;
public static synchronized Lazyman getInstance2(){
if(lazyman==null){
lazyman=new Lazyman();
}
return lazyman;
}
但同步锁会增加锁竞争，带来系统性能开销，从而导致系统性能下降，因此这种方式也会降低单例模式的性能。
还有，每次请求获取类对象时，都会通过 getInstance2() 方法获取，除了第一次为 null，其它每次请求基本都是不为 null 的。在没有加同步锁之前，是因为 if 判断条件为 null 时，才导致创建了多个实例。基于以上两点，我们可以考虑将同步锁放在 if 条件里面，这样就可以减少同步锁资源竞争。
你是不是觉得这样就可以了呢？答案是依然会创建多个实例。这是因为当多个线程进入到 if 判断条件里，虽然有同步锁，但是进入到判断条件里面的线程依然会依次获取到锁创建对象，然后再释放同步锁。所以我们还需要在同步锁里面再加一个判断条件.
双重校验+锁（推荐）
这里使用到了volatile关键字，volatile的一个语义是禁止指令重排序优化，也就保证了instance变量被赋值的时候对象已经是初始化过的，从而避免指令重排。
// 懒汉模式 + synchronized 同步锁 + double-check
private Lazyman(){}
private volatile static Lazyman lazyman;
public static Lazyman getInstance3(){
if(lazyman==null){
synchronized (Lazyman.class){
if(lazyman==null){
lazyman=new Lazyman();//不是一个原子性操作
/*
* new对象的步骤（可能会发生指令重排，即执行顺序不是123，可能是132）
* 1。分配内存空间
* 2。执行构造方法，初始化对象
* 3。把这个对象指向这个空间
* 如果是132，此时lazyman还没有完成构造，会认为lazyman!==null
* 原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序不可以被打乱，也不可以被切割而只执行其中的一部分。
* */
}
}
}
return lazyman;
}
静态内部类（推荐）
//懒汉式 静态内部类实现
public class Holder {
private Holder(){
}
private static Holder getInstance(){
return InnerClass.HOLDER;// 返回内部类中的静态变量
}
//内部类实现
public static class InnerClass{
private static final Holder HOLDER=new Holder();//自己创建实例
}
}
- 这种方式同样利用了类加载机制来保证只创建一个instance实例。它与饿汉模式一样，也是利用了类加载机制，因此不存在多线程并发的问题。
- 不一样的是，它是在内部类里面去创建对象实例。
- 这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全。
枚举（强烈推荐）
//enum本身就是一个class类
//枚举方式实现单例模式
//枚举类型是线程安全的，并且只会装载一次
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance(){
return INSTANCE;
}
}
//测试用例
class Test{
public static void main(String[] args) {
EnumSingle instance1=EnumSingle.INSTANCE;
EnumSingle instance2=EnumSingle.INSTANCE;
System.out.println(instance1);
System.out.println(instance2);
}
}
输出：
INSTANCE
INSTANCE
可以看出俩个instance哈希值是一样的
下面我们来看看单例是如何被保证的：
1.首先，在枚举中我们明确了构造方法限制为私有，在我们访问枚举实例时会执行构造方法。
2.同时每个枚举实例都是static final类型的，也就表明只能被实例化一次。在调用构造方法时，我们的单例被实例化。
3.也就是说，因为enum中的实例被保证只会被实例化一次，所以我们的INSTANCE也被保证实例化一次。
单例模式的线程安全性
首先要说的是单例模式的线程安全意味着：某个类的实例在多线程环境下只会被创建一次出来。单例模式有很多种的写法，我总结一下：
（1）饿汉式：线程安全
（2）懒汉式：非线程安全
（3）双检锁：线程安全
（4）静态内部类：线程安全
（5）枚举：线程安全
如何选择
如果我们在程序启动后，一定会加载到类，那么用饿汉模式实现的单例简单又实用；
如果我们是写一些工具类，则优先考虑使用懒汉模式，因为很多项目可能会引用到 jar 包，但未必会使用到这个工具类，懒汉模式实现的单例可以避免提前被加载到内存中，占用系统资源。
参考： https://blog.csdn.net/fly910905/article/details/79286680