【设计模式】单例设计模式--解析-优快云博客

1、概念：单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点

2、单例模式（Singleton），定义了一个GetInstance操作，允许客户访问它的唯一实例。GetInstance是一个静态方法，主要负责创建自己的唯一实例。

class Singleton
 {
   private static Singleton instance;
   private Singleton(){
    //构造方法让其private，这就堵死了外界利用new创建此类实例的可能
   }
   public static Singleton GetInstance(){ //此方法是获得本类实例的唯一全局访问点
    if(instance == null){ //若实例不存在，则new一个新实例，否则返回已有的实例
        instance = new Singleton();
    }
    return instance;
   }
 }

3、单例模式的特性：

单例模式只能有一个实例
单例类必须自己创建自己的唯一实例
单例类必须给所有其他对象提供这一实例

4、单例模式的应用：

为何要用单例模式？

对于系统中的某些类来说，只有一个实例很重要，例如，一个系统只能有一个窗口管理器或者文件系统；一个系统只能有一个计时工具或者ID(序号)生成器

比如打印机、线程池、对话框等被设置为单例模式

5、单例模式的分类：

1）懒汉式：需要用时才去创建对象

2）饿汉式：创建类的实例时就去创建对象

6、懒汉式：

    //懒汉式单例类.在第一次调用的时候实例化自己   
    public class Singleton {  
        private Singleton() {}  
        private static Singleton single=null;  
        //静态工厂方法   
        public static Singleton getInstance() {  
             if (single == null) {    
                 single = new Singleton();  
             }    
            return single;  
        }  
    }

将构造方法限定为private，避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。但是以上懒汉式单例的实现没有考虑线程安全的问题，它是线程不安全的，并发环境下可能出现多个Singleton实例，要实现线程安全，有以下几种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全：

（1）在getInstance方法上加同步关键字synchronized，但影响执行效率，一个线程调用，其他线程则需等待

public static synchronized Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
}

（2）加双重检查锁，比较高效

    public static Singleton getInstance() {  
            if (singleton == null) {    //第一次判断
                synchronized (Singleton.class) {    
                   if (singleton == null) {    //第二次判断
                      singleton = new Singleton();   
                   }    
                }    
            }    
            return singleton;   
        }

为什么需要双重检查锁呢？因为第一次检查是确保之前是一个空对象，而非空对象就不需要同步了，空对象的线程然后进入同步代码块，如果不加第二次空对象检查，两个线程同时获取同步代码块，一个线程进入同步代码块，另一个线程就会等待，而这两个线程就会创建两个实例化对象，需要在线程进入同步代码块后再次进行空对象检查，才能确保只创建一个实例对象

需要特别注意的是一定要加volatile关键字，这样才能保证在内存中访问到的是最新值，从而有效的做双重判断，保证只有一个instance对象

（3）静态内部类

public class Singleton {
    private static class SingletonHodler {
        private static Singleton ourInstance = new Singleton();
    }

    public synchronized static Singleton getInstance() {
        return SingletonHodler.ourInstance;
    }

    private Singleton() {
    }
}

利用静态内部类，某个线程在调用该方法时会创建一个实例化对象

7、饿汉式：

    //饿汉式单例类.在类初始化时，已经自行实例化   
    public class Singleton1 {  
        private Singleton1() {}  
        private static final Singleton1 single = new Singleton1();  
        //静态工厂方法   
        public static Singleton1 getInstance() {  
            return single;  
        }  
    }

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的

以上三种方法的区别：

（1）在方法上加了同步，虽然线程安全，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的

（2）在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，线程安全，同时避免了每次都要同步的性能损耗

（3）利用classloader的机制来保证初始化是只有一个线程，所以也是线程安全的，没有性能损耗

8、懒汉式和饿汉式的区别：

饿汉式就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例已经是存在的了

而懒汉式比较懒，只有当调用getInstance的时候，才回去初始化这个单例

（1）线程安全：

饿汉式是线程安全的，可以直接用于多线程而不会出现问题

懒汉式本身是非线程安全的，为了实现线程安全有以上几种方法

（2）资源加载和性能：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成

懒汉式会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了

9、指令重排序

懒汉式的双重检查版本的单例模式，一定是线程安全的吗？不一定，因为在JVM的编译过程中会存在指令重排序的问题

（1）在创建一个对象的时候，包含三个过程：

对于singleton = new Singleton()，这不是原子操作，在JVM中包含的三个过程

1 给singleton分配内存
2 调用Singleton的构造函数来初始化成员变量，形成实例
3 将singleton对象指向分配的内存空间（singleton才是非null）

（2）但是，由于JVM会进行指令重排序，所以上面的第二步和第三步的顺序不能保证，最终的执行顺序可能是1-2-3，也可能是1-3-2，如果是1-3-2，则在3执行完毕，2未执行之前，被另一个线程抢占了，这是instance已经是非null了，但是没有初始化，所以这个线程会直接返回instance，然后使用，肯定报错

（3）解决方法：把 singleton声明成volatile,改进后的懒汉式线程安全(双重检查锁)的代码如下：

public class Singleton {
    //volatile的作用是：保证可见性、禁止指令重排序，但不能保证原子性
    private volatile static Singleton ourInstance;

    public synchronized static Singleton getInstance() {
        if (null == ourInstance) {
            synchronized (Singleton.class) {
                if (null == ourInstance) {
                    ourInstance = new Singleton();
                }
            }
        }
        return ourInstance;
    }

10、单例模式在JDK8源码中的使用

（1）Runtime类部分源码如下：

/饿汉式单例设计模式
public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }

    private Runtime() {
    }

    //省略很多行
}