Java单例模式的6种写法

在Java中，单例有很多种写法，面试时，手写代码环节，除了写算法题，有时候也会让手写单例模式，这里记录一下单例的几种写法和优缺点。

• 初级写法
• 懒汉式
• 饿汉式
• 双锁检验
• 内部类
• 枚举式

1.初级写法

public class Singleton {

    private static Singleton singleton = null;

    public Singleton() {
    }

    /**并发下会产生多个实例*/
    public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

 上面这种写法，在并发环境下，会出现多个实例。

2.懒汉式

我们优化上面的代码，遇到并发，很容易想到加锁，把获取对象的方法加上关键字synchronized，这种写法称为懒汉式单例，如下：

public class BSingleton {
    
    private static BSingleton bSingleton;

    private BSingleton() {
    }

    /**
     * 整个方法锁住了，效率较低
     * @return
     */
    public synchronized static BSingleton getbSingleton(){
        if(bSingleton == null){
            bSingleton = new BSingleton();
        }
        return bSingleton;
    }
}

懒汉式的特点是，用到这个实例时才去调用方法实例化。但是，我们把整个方法都同步了，效率很低下，我们可以继续优化，只在创建实例的地方加上同步，参考5双锁检验。

3.饿汉式

饿汉式的特点是：类在加载时就直接初始化了实例。即使没用到，也会实例化，因此，也是线程安全的单例模式。

public class ESingleton {

    /**类在加载的时候直接进行初始化*/
    private static final ESingleton ESINGLETON = new ESingleton();

    private ESingleton() {}

    /**对外暴露唯一接口  提供单例对象*/
    public static ESingleton geteSingleton(){
        return ESINGLETON;
    }
}

4.双锁检验

双重非空判断，new对象前加一次锁。

volatile关键字，考虑的是，new关键字在虚拟机中执行时其实分为很多步骤，具体原因可以参考深入理解java虚拟机一书（考虑的是这个new关键字字节码执行时是非原子性的），而volatile关键字可以防止指令重排。

public class SynchronizedSingleton {

    /**volatile防止指令重排*/
    private static volatile SynchronizedSingleton singleton;

    private SynchronizedSingleton() {
    }

    /**只是在实例为空时才进行同步创建
     * 为什么做了2次判断？
     * A线程和B线程同时进入同步方法0
     * 然后都在1位置处判断了实例为null
     * 然后都进入了同步块2中
     * 然后A线程优先进入了同步代码块2中（B线程也进入了），然后创建了实例
     * 此时，如果没有3处的判断，那么A线程创建实例同时，B线程也会创建一个实例
     * 所以，还需要做2次判断
     * */
    public static SynchronizedSingleton getInstance(){//0
        if(singleton == null){//1
            synchronized (SynchronizedSingleton.class){//2
                if(singleton == null){//3
                    singleton = new SynchronizedSingleton();//4
                }
            }
        }
        return singleton;
    }
}

5.内部类

public class Singleton {

    private static class SingletonHolder{
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton (){}
 
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

优点：由于静态内部类跟外部类是平级的，所以外部类加载的时候不会影响内部类，因此实现了lazy loading, 同时也是利用静态变量的方式，使得INSTANCE只会在SingletonHolder加载的时候初始化一次，从而保证不会有多线程初始化的情况，因此也是线程安全的。

6.枚举式

public enum Singleton{
    INSTANCE;
    public void whateverMethod() {
        
    }
}

 这是知名书籍Java Effective推荐的单例实现方式，这种代码最简练，并且天生线程安全。

推广：一个好消息

同学，你造吗？阿里云和腾讯云已白菜价，云服务器低至不到300元/年。这里有一份云计算优惠活动列表，来不及解释了，赶紧上车！