单例模式的写法总结

单例模式简介

使用场景

• 单例模式算是最简单的设计模式，就像名字中的单例一样，只存在一个实例。一般适用于一下集中情况：
  1. 系统只需要一个对象存在的时候
  2. 对象比较大占用资源比较多的时候
  3. 构建比较复杂，且不需要多个对象的时候
  4. 比较紧缺的资源对象，比如只有一个打印机

饿汉式

• 饿汉式为单例模式的一种写法，意思是在类加载的时候就初始化对象，不管对象是否有调用，该模式为线程安全的模式，但是会造成一些可能存在的资源浪费（运行过程中未使用到该实例）和启动初始化速度变慢的可能性。该模式写法也比较简单，代码如下：

/**
 * @author kiven
 * @Date 2020-03-01-4
 * 单例模式-饿汉式
 */
public class HungrySingleInstance {
    private static HungrySingleInstance INSTANCE = new HungrySingleInstance();

    private HungrySingleInstance() {
    }

    public static HungrySingleInstance getInstance() {
        return INSTANCE;
    }
}

• 由于对象为静态初始化变量，在类加载时初始化，类加载过程由jvm保证线程安全，所以该模式为线程安全模式。饿汉式还有一种写法，就是使用静态代码块初始化静态变量(但是这个写法要注意顺序，如果静态初始化变量写在静态变量定义之前，则会出现静态变量为null的情况，我用java8测试过，没有该情况出现，不知道是不是java8做了优化处理)，正常的代码：

/**
 * @author kiven
 * @Date 2020-03-01-14 15：23
 * 单例模式-饿汉式(静态代码块)
 */
public class HungrySingleInstance2 {
    private static HungrySingleInstance2 INSTANCE;
    
    //静态初始化代码在定义之后
    static {
        INSTANCE = new HungrySingleInstance2();
    }
    private HungrySingleInstance2() {
    }

    public static HungrySingleInstance2 getInstance() {
        return INSTANCE;
    }
}

懒汉式

• 懒汉式，默认不初始化，即在第一次使用该对象时初始化

  1. 最简单的懒汉式写法（线程不安全，不推荐）

  在使用的时候判断对象是否已经创建，如果未创建则new一个新对象，并赋值给静态变量，并返回该对象，如果已经创建则直接返回该对象。代码如下：

/**
 * @Description 最简单的懒汉式--线程不安全
 * @Author kiven
 * @Date 2020/3/14 14:53
 */
public class SimpleLazySingleInstance {
    private static SimpleLazySingleInstance INSTANCE;

    public static SimpleLazySingleInstance getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new SimpleLazySingleInstance();
        }
        return INSTANCE;
    }

    private SimpleLazySingleInstance() {
    }

}

可以看到代码并未做任何的同步控制，所以多线程下可能会出现多个对象，所以不是线程安全的。

2. 加同步方法的单利（线程安全，不推荐）

我们知道上面的方法由于多线程访问，可能会生成多个对象，java中可以通过synchronized控制并发访问，所以只要对**getInstance()**方法加上并发访问控制即可避免多线程访问的不安全。

/**
 * @Description 同步方法的懒汉式--线程安全
 * @Author kiven
 * @Date 2020/3/14 14:53
 */
public class SafeLazySingleInstance {
    private static SafeLazySingleInstance INSTANCE;

    public static synchronized SafeLazySingleInstance getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new SafeLazySingleInstance();
        }
        return INSTANCE;
    }

    private SafeLazySingleInstance() {
    }

}

由于锁定了方法，所以每个线程进来时都会进入锁状态，会造访问速度变慢，其实我们至需要第一次进入时判断为null锁定，进入同步状态即可，后面调用该方法时则可以直接返回已生成对象即可。所以需要对同步代码块进行锁定即可。

同步代码块锁定的单利模式（线程安全）

/**
 * @Description 同步代码块的懒汉式--线程安全
 * @Author kiven
 * @Date 2020/3/14 14:53
 */
public class SafeLazySingleInstance {
    private static SafeLazySingleInstance INSTANCE;

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

    private SafeLazySingleInstance() {
    }

}

这里加了连个是否为null判断，是因为外层判断可能会有个线程判断到该情况，所以同步代码块中再进行一次判断，保证只有第一次判断为null时才会新建对象，后面再新建对象时则会判断到对象部位null，确保了单利的准确性。比如说线程A判断到对象为null，此时线程中断，切换到线程B，线程B也执行到判断对象是否为null，则此时两个线程都会在后面的执行中进入同步代码块的处理逻辑，所以内部还需要在进行一次为空判断。
但是这个写法在我一次面试中被问到过，该写法也有小概率线程不安全，问问我有没有什么办法再优化？最后面试官提醒我应该加上一个volatile关键字，volatile关键字的作用主要是强制线程间的变量同步，且提示编译器，不对该变量的初始化过程做优化。比如线程A改变了volatile关键字修饰的变量，线程A必须先将该变量的值从线程A的副本中写入主内存，并且线程B使用时则必须从主内存中读取改变量的值到线程B的变量副本中，且中间不能插入任何其他操作。借用网上说的大白话就是：被volatile修饰后的变量变化可以被其他线程感知，避免工作副本修改后产生的脏数据，优化后的写法如下：

 * @Description 同步代码块的懒汉式--线程安全
 * @Author kiven
 * @Date 2020/3/14 13:23
 */
public class SafeLazySingleInstance {
    private static volatile SafeLazySingleInstance INSTANCE;

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

    private SafeLazySingleInstance() {
    }

}

使用内部类生成的单利–（线程安全）

我们也可以使用jvm来帮我们控制线程安全，生产单利模式，也是比较常见的单利模式的写法，使用内部类生产单利对象，代码如下：‘

/**
 * @Description 内部类控制生成的懒汉式--线程安全
 * @Author kiven
 * @Date 2020/3/14 14:53
 */
public class InnerClassSingleInstance {

    public static InnerClassSingleInstance getInstance() {
        return InstnanceProvidor.INSTANCE;
    }

    private InnerClassSingleInstance() {
    }

    private static class InstnanceProvidor {
        private static InnerClassSingleInstance INSTANCE = new InnerClassSingleInstance();
    }

}

该模式下也是线程安全的懒汉式，第一次调用时classloader才会去加载内部类，并初始化静态对象。

使用枚举控制的单利

此外我还看到过别人的视频中说过，可以使用枚举类型来实现单例模式，代码如下：

/**
 * @Description 枚举控制生成的懒汉式--线程安全
 * @Author kiven
 * @Date 2020/3/14 16:13
 */
public class EnumSingleInstance {
    private static EnumSingleInstance INSTANCE = new EnumSingleInstance();

    public static EnumSingleInstance getInstance() {
        return SingleEnum.SINGLE_ENUM.getInstance();
    }

    private EnumSingleInstance() {
    }

    private enum SingleEnum {
        SINGLE_ENUM;
        
        //jvm控制只调用一次
        SingleEnum(){
            INSTANCE = new EnumSingleInstance();
        }
        
        EnumSingleInstance getInstance() {
            return INSTANCE;
        }
    }

}

这个写法感觉和静态内部类的写法非常类似，也是由jvm控制只生成一个实例，我也是最近才学到原来还可以这样写单例。