1.单例设计模式

单例模式:保证一个类仅有一个实例，并提供一个该实例的全局访问点。——《设计模式》

为什么需要？系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

上述定义总结以下特点大致有3点：

（1）单例类只有一个实例对象；
（2）该单例对象必须由单例类自行创建；
（3）单例类对外提供一个访问该单例的全局访问点。

单例的应用场景

单例模式的核心精髓其实是避免创建不必要的对象

不必要的对象一般是：

（1）频繁创建的一些类，又频繁被销毁
（2）“昂贵的对象”，有些对象创建的成本比其他对象要高得多，比如占用资源较多，或实例化耗时较长
（3）系统要求单一控制逻辑的操作，或者对象需要被共享的情况

常见的使用场合：数据库的连接池、Spring中的全局访问点BeanFactory，Spring下的Bean、多线程的线程池、网络连接池等等单例模式的

优点：

不仅可以减少每次创建对象的时间开销，还可以节约内存空间； 能够避免由于操作多个实例导致的逻辑错误； 
如果一个对象有可能贯穿整个应用程序，能够起到了全局统一管理控制的作用。

缺点：

单例模式一般没有接口，没有抽象层，扩展困难。如果要扩展，得修改原来的代码。
单例模式的功能代码通常写在一个类中，其职责过重，如果功能设计不合理，则很容易违背单一职责原则，
不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。比如单例模式下去将对象转成json 会出现互相引用的问题。

单例模式五种实现方式：

1、饿汉式(线程安全，调用效率高，但是不能延时加载)

public class ImageLoader{ 
     private static ImageLoader instance = new ImageLoader; 
     private ImageLoader(){} 
     public static ImageLoader getInstance(){  
          return instance;  
      } 
}

　　一上来就把单例对象创建出来了，要用的时候直接返回即可，这种可以说是单例模式中最简单的一种实现方式。

　　预加载：单例在还没有使用到的时候，初始化就已经完成了。也就是说，如果程序从头到位都没用使用这个单例的话，单例的对象还是会创建。这就造成了不必要的资源浪费。所以不推荐这种实现方式。

2.懒汉式(线程安全，调用效率不高，但是能延时加载)：懒加载

public class SingletonDemo2 {
    //类初始化时，不初始化这个对象(延时加载，真正用的时候再创建)
    private static SingletonDemo2 instance;
    //构造器私有化
    private SingletonDemo2(){}
    //方法同步，调用效率低
    public static synchronized SingletonDemo2 getInstance(){
        if(instance==null){
            instance=new SingletonDemo2();
        }
        return instance;
    }
}

　　效率太低，每个线程在想获得类的实例时候，执行 getInstance() 方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低要改进。

3.Double CheckLock实现单例：DCL也就是双重锁判断机制（由于JVM底层模型原因，偶尔会出问题，不建议使用）：

public class SingletonDemo5 {
        private volatile static SingletonDemo5 SingletonDemo5;
        private SingletonDemo5() {
        }
        public static SingletonDemo5 newInstance() {
            if (SingletonDemo5 == null) {
                synchronized (SingletonDemo5.class) {
                    if (SingletonDemo5 == null) {
                        SingletonDemo5 = new SingletonDemo5();
                    }
                }
            }
            return SingletonDemo5;
        }
    }

（1）这种方式为什么要检查两次？检查一次行不行？

　　第一次判断singleton == null作用是，如果单例对象已经创建，就直接返回对象，不需要进入同步锁，提高效率

　　第二次判断singleton == null，假如没有这个判断，多个线程同时通过第一次singleton == null之后，只有一个线程进入临界区，其他线程排队，没有第二次检查的话，会创建多个实例，第二次是必须检查

（2）在代码1处使用了关键字volatile，为什么需要？

　　因为 JVM 指令重排序，也就是并不限制处理器的指令顺序，说白了就是在不影响结果的情况下，顺序可能会被打乱。

4.静态内部类实现模式（线程安全，调用效率高，可以延时加载）

public class SingletonDemo3 {
    private static class SingletonClassInstance{
        private static final SingletonDemo3 instance=new SingletonDemo3();
    }
    private SingletonDemo3(){}
    public static SingletonDemo3 getInstance(){
        return SingletonClassInstance.instance;
    }
}

5.枚举类（线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用）

public enum SingletonDemo4 {
    //枚举元素本身就是单例
    INSTANCE;
    //添加自己需要的操作
    public void singletonOperation(){
    }
}

如何选用：

-单例对象占用资源少，不需要延时加载，枚举好于饿汉

-单例对象占用资源多，需要延时加载，静态内部类好于懒汉式

饿汉式/静态内部类/枚举是通用什么方式保证线程安全？

　　以上的静态内部类、饿汉等模式均是通过定义静态的成员变量，以保证单例对象可以在类初始化的过程中被实例化。

　　这其实是利用了ClassLoader的线程安全机制。ClassLoader的loadClass方法在加载类的时候使用了synchronized关键字。

　　所以，除非被重写，这个方法默认在整个装载过程中都是线程安全的。所以在类加载过程中对象的创建也是线程安全的。

扩展讨论：

那么这些方式都是和synchronized有关系的，有没有哪种方式可以完全不使用synchronized的吗？

6.CAS（AtomicReference）实现单例模式

public class Singleton { 
　　private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>(); 
　　private Singleton() {} 
　　public static Singleton getInstance() { 
　　for (;;) {
            Singleton singleton = INSTANCE.get(); if (null != singleton) { 
　　　　　　　　　　return singleton;
            }
            singleton = new Singleton(); 
　　　　　　　if (INSTANCE.compareAndSet(null, singleton)) { 
　　　　　　　　　　return singleton;
            }
        }
    }
}

优点：用CAS的好处在于不需要使用传统的锁机制来保证线程安全，CAS是一种基于忙等待的算法，依赖底层硬件的实现，相对于锁它没有线程切换和阻塞的额外消耗，可以支持较大的并行度。（CAS具体可以在JUC那块分享）

缺点：CAS的一个重要缺点在于如果忙等待一直执行不成功(一直在死循环中)，会对CPU造成较大的执行开销。

　　另外，代码中，如果N个线程同时执行到 singleton = new Singleton();的时候，会有大量对象被创建，可能导致内存溢出。

7.ThreadLocal实现单例模式

　　这种方式仅了解，不推荐使用，因为它其实失去了单例的意义

ThreadLocal 和同步模式创建的单例区别：

　　ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。对于多线程资源共享的问题，同步机制(synchronized)采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。这种是同步机制仅提供一份变量，让不同的线程排队访问，而ThreadLocal为每一个线程都提供了一份变量，因此可以同时访问而互不影响。