博客同步

单例模式作为常用的设计模式之一，无论是在各种第三方库还是在我们日常开发中都非常常见，这里将介绍单例模式七种实现方式。

前提：jvm类加载

class 加载流程： 加载—–验证—–准备—–解析—–初始化
在class文件中java编译器会生成一个<clinit>()方法，在初始化阶段jvm会调用它，该方法包含了对该类所有的静态变量的赋值和静态代码块执行操作，并且 jvm保证了<clinit>()方法在多线程的执行环境下安全，因此单例设计模式模式中我们使用静态变量来存储实例的引用。

一、单例模式之饿汉式

/**
 * 饿汉式
 */
public class SingletonDemo {

    //当类加载初始化后，就已经完成了实例的创建
    private static SingletonDemo instance = new SingletonDemo();

    /**
     * 不让外部 new
     */
    private SingletonDemo() {

    }

    public static SingletonDemo getInstance() {
        return instance;
    }

}

饿汉式分析

饿汉式的关键使用了静态变量并且在类加载初始化后就完成了实例的创建，从而保证了多线程环境下实例的一致性，但是它不支持懒加载，当然如果过该类比较轻的话还是可以接受的。

二、单例模式之懒汉式

/**
 * 懒汉式
 */
public class SingletonDemo {
    
    //仅仅定义静态变量
    private static SingletonDemo instance = null;

    /**
     * 不让外部 new
     */
    private SingletonDemo() {

    }

    public static SingletonDemo getInstance() {
        
        return instance!=null?instance:new SingletonDemo();
    }

}

懒汉式分析

懒汉式仅仅在在使用实例的时候才去创建实例的对象，在多线程环境下，实例可能会创建多次，线程不安全，但是它支持懒加载。

三、线程安全懒汉式

/**
 * 线程安全懒汉式
 */
public class SingletonDemo {

    //仅仅定义静态变量
    private static SingletonDemo instance = null;

    /**
     * 不让外部 new
     */
    private SingletonDemo() {

    }

    //使用synchronized 同步关键字，保证该方法多线程下只能单个线程使用
    public synchronized static SingletonDemo getInstance() {

        return instance!=null?instance:new SingletonDemo();
    }

}

线程安全懒汉式分析

通过synchronized 关键字修饰 getInstance方法实现线程安全，但是同一时刻只能有一个线程访问，性能较低。

四、单例模式之双重检验

/**
 * 双重检验模式
 */
public class SingletonDemo {

    //仅仅定义静态变量
    private static SingletonDemo instance = null;

    /**
     * 不让外部 new
     */
    private SingletonDemo() {

    }

    public static SingletonDemo getInstance() {
        
        if (instance==null){
            
            //同步代码块
            synchronized (SingletonDemo.class){
                if (instance == null) {
                    instance = new SingletonDemo();
                }
            }
            
        }
        return instance;
    }

}

双重检验分析

这种模式可能会引起空指针异常，new 一个对象需要经历：分配内存空间-初始化-引用赋值（指向对象的地址）过程,而且java中存在cpu指令重排序，因此在多线程环境下线程一执行 可能执行new对象:分配内存空间-引用赋值-初始化，当执行到引用赋值时，线程二会看到instance!=null，但这时，对象并未完成初始化，对象是空的，直接使用会空指针异常。因此这种方式也是线程不安全的。

volatile双重检验

/**
 * volatile双重检验模式
 */
public class SingletonDemo {

    //仅仅定义静态变量
    private volatile static SingletonDemo instance = null;

    /**
     * 不让外部 new
     */
    private SingletonDemo() {

    }

    public static SingletonDemo getInstance() {

        if (instance==null){

            //同步代码块
            synchronized (SingletonDemo.class){
                if (instance == null) {
                    instance = new SingletonDemo();
                }
            }

        }
        return instance;
    }

}

volatile双重检验分析

volatile 在这的作用就是禁止指令重排序，从而使对象的创建严格按照分配内存空间-初始化-引用赋值（指向对象的地址）过程，实现了线程安全。

静态内部类模式

/**
 * 静态内部类模式
 */
public class SingletonDemo {

    

    /**
     * 不让外部 new
     */
    private SingletonDemo() {

    }
    

    public static SingletonDemo getInstance() {
        return Holder.instance;
    }
    
    //使用静态内部类来初始化instance
    private static class Holder{
        
        //当类加载初始化后，就已经完成了实例的创建
        private static SingletonDemo instance = new SingletonDemo();
        
    }

}

静态内部类模式分析

静态内部类模式归根到底是<clinit>（）同步方法带来的结果，这种模式实现了线程安全和懒加载，被公认为最好的单例模式之一。

枚举模式

/**
 * 枚举模式
 */
public class SingletonDemo {



    /**
     * 不让外部 new
     */
    private SingletonDemo() {

    }


    public static SingletonDemo getInstance() {
        return Holder.INSTANCE.instance;
    }

    //使用枚举
    private  enum  Holder{

        INSTANCE;
        private SingletonDemo instance;
        
        Holder(){
            instance = new SingletonDemo();
        }

    }

}

枚举模式分析

主要利用了enum的特性，保证线程安全。

总结

各种模式各有有缺点，但是对懒加载和高性能有要求的，还是用静态内部类类模式、volatile双重检验模式、枚举模式，既能满足线程安全，还能满足性能要求。