浅析单例模式的8中写法

行百里er

发布于 2020-12-02 14:29:25

4200

发布于 2020-12-02 14:29:25

文章被收录于专栏：JavaJourney

开局一张图，23种设计模式直抵脑海啊有木有！这篇文章只针对单例模式的几种写法做一个浅析。

单例模式

保证类只有一个实例。当我们的类只需要有一种实例的时候就可以用这种模式。比如各种管理类 Manager，各种工厂类 Factory

单例模式的 8 种写法

1. 俗称“饿汉式”的写法

/**
 * 类加载的时候就实例化一个实例，JVM保证线程安全
 * 也称饿汉式
 * 该方式简单实用
 * @author traveler100
 */
public class Singleton_1 {
    private static final Singleton_1 INSTANCE = new Singleton_1();

    /**
     * 私有的构造方法，其他地方不能new
     */
    private Singleton_1() {
    }

    public static Singleton_1 getInstance() {
        return INSTANCE;
    }

    /**
     * for test
     */
    public static void main(String[] args) {
        Singleton_1 instance1 = Singleton_1.getInstance();
        Singleton_1 instance2 = Singleton_1.getInstance();
        System.out.println(instance1 == instance2);
    }
}

这种写法简单实用，推荐使用。用着放心。

2. 意思同第一种，只是写法不同

/**
 * 和Singleton_1是同一个意思
 * 只是将new的动作放在了代码块里
 * 类加载到内存的时候只加载一个实例
 * @author traveler100
 */
public class Singleton_2 {
    private static final Singleton_2 INSTANCE;

    static {
        INSTANCE = new Singleton_2();
    }

    /**
     * 私有的构造方法，其他地方不能new
     */
    private Singleton_2() {
    }

    public static Singleton_2 getInstance() {
        return INSTANCE;
    }

    /**
     * for test
     */
    public static void main(String[] args) {
        Singleton_2 instance1 = Singleton_2.getInstance();
        Singleton_2 instance2 = Singleton_2.getInstance();
        System.out.println(instance1 == instance2);
    }
}

3. 懒汉式，用到的时候才实例化

/**
 * 懒汉式
 * 这种写法虽然达到了用的时候才初始化的目的，但是存在多线程获取实例时相互影响的问题
 * @author traveler100
 */
public class Singleton_3 {
    private static Singleton_3 INSTANCE;

    /**
     * 私有的构造方法，其他地方不能new
     */
    private Singleton_3() {
    }

    public static Singleton_3 getInstance() {
        if (INSTANCE == null) {
            // sleep一下，测试
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Singleton_3();
        }
        return INSTANCE;
    }

    /**
     * for test
     */
    public static void main(String[] args) {
        //同一个类的不同对象的hashcode不同
        //跑100个线程，看看有没有不同的实例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(Singleton_3.getInstance().hashCode())).start();
        }
    }
}

运行结果：

这种写法虽然达到了用的时候才初始化的目的，但是存在多线程获取实例时相互影响的问题。

4. 在上一种写法的基础上加 synchronized 锁，保证线程安全

/**
 * lazy loading 懒汉式
 * 这种写法虽然达到了用的时候才初始化的目的，但是存在多线程获取实例时相互影响的问题
 * 可以用synchronized加锁，但是效率会降低
 * @author traveler100
 */
public class Singleton_4 {
    private static Singleton_4 INSTANCE;

    /**
     * 私有的构造方法，其他地方不能new
     */
    private Singleton_4() {
    }

    /**
     * 既然lazy loading的写法有线程安全问题，那就加把锁
     */
    public static synchronized Singleton_4 getInstance() {
        if (INSTANCE == null) {
            // 测试，sleep一下，增加被其他线程打断的机会
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Singleton_4();
        }
        return INSTANCE;
    }

    /**
     * for test
     */
    public static void main(String[] args) {
        //同一个类的不同对象的hashcode不同
        //跑100个线程，看看有没有不同的实例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(Singleton_4.getInstance().hashCode())).start();
        }
    }
}

这种方式可行，但会带来效率下降的问题。下面继续“吹毛求疵”。

5. 既然 4 的的写法效率下降，那就在线程安全的基础上减少锁住的代码数量，这里有坑

/**
 * lazy loading 懒汉式
 * 这种写法虽然达到了用的时候才初始化的目的，但是存在多线程获取实例时相互影响的问题
 * 可以用synchronized加锁，但是效率会降低
 * 在加锁的基础上再优化一下，减少加锁代码块的数量
 * @author traveler100
 */
public class Singleton_5 {
    private static Singleton_5 INSTANCE;

    /**
     * 私有的构造方法，其他地方不能new
     */
    private Singleton_5() {
    }

    public static Singleton_5 getInstance() {
        if (INSTANCE == null) {
            //不在方法上加锁而在new的时候才加锁，减少锁的代码，然而这种方式并不行
            synchronized (Singleton_5.class) {
                // 测试，sleep一下，增加被其他线程打断的机会
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Singleton_5();
            }
        }
        return INSTANCE;
    }

    /**
     * for test
     */
    public static void main(String[] args) {
        //同一个类的不同对象的hashcode不同
        //跑100个线程，看看有没有不同的实例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(Singleton_5.getInstance().hashCode())).start();
        }
    }
}

先看运行结果：

说明这种写法看似在线程安全的基础上减少了锁的代码量，其实是达不到“永远”单例的目的的。

原因:线程 A 运行完if(INSTANCE == null)，还没拿到锁时候，线程 B 也运行到if(INSTANCE == null)这一句了，并且拿到锁进行了 new 实例化，然后线程 B 释放锁，线程 A 得到锁继续运行if语句块里面的内容进行 new 的过程，这样就出现了不同的实例了。

6. 那就来个双重检查吧

/**
 * lazy loading 懒汉式
 * 这种写法虽然达到了用的时候才初始化的目的，但是存在多线程获取实例时相互影响的问题
 * 可以用synchronized加锁，但是效率会降低
 * 在加锁的基础上再优化一下，减少加锁代码块的数量---事实证明不可行
 * 那就双重检查DCL
 * @author traveler100
 */
public class Singleton_6 {
    private static Singleton_6 INSTANCE;

    /**
     * 私有的构造方法，其他地方不能new
     */
    private Singleton_6() {
    }

    public static Singleton_6 getInstance() {
        if (INSTANCE == null) { //第一重检查
            synchronized (Singleton_6.class) {
                if (INSTANCE == null) { //第二重检查
                    // 测试，sleep一下，增加被其他线程打断的机会
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Singleton_6();
                }
            }
        }
        return INSTANCE;
    }

    /**
     * for test
     */
    public static void main(String[] args) {
        //同一个类的不同对象的hashcode不同
        //跑100个线程，看看有没有不同的实例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(Singleton_6.getInstance().hashCode())).start();
        }
    }
}

INSTANCE 要不要加volatile？答案是肯定的。众所周知，volatile 的作用是保证线程可见性和禁止指令重排序。在 DCL 单例模式写法中，volatile 主要是用于禁止指令重排序的。因为如果不加 volatile 关键字，那么可能会出现指令重排序。一个线程A执行到 INSTANCE = new Singleton_6()的时候，经过编译器编译，会分成三个指令：

给指令申请内存
给成员变量初始化
把这块内存的内容赋值给 INSTANCE

既然有值了，那么线程B上来先进行检查发现已经有值，就不会进入加锁那部分的代码了。加了volatile后，就不允许指令重排序了。所以此时一定是保证线程A初始化完了才会复制给这个变量。

7. 静态内部类方式

/**
 * 静态内部类方式
 * JVM保证单例
 * 加载外部类时不会加载内部类---也可实现懒加载
 * @author traveler100
 */
public class Singleton_7 {

    /**
     * 私有的构造方法，其他地方不能new
     */
    private Singleton_7() {
    }

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

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

    /**
     * for test
     */
    public static void main(String[] args) {
        //同一个类的不同对象的hashcode不同
        //跑100个线程，看看有没有不同的实例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(Singleton_7.getInstance().hashCode())).start();
        }
    }
}

即可保证单例（虚拟机保证），也能实现懒加载。如果非要追求完美，那么可以用这种方式。

8. 完美中的完美方式，Enum 实现单例

/**
 * 枚举单例
 * 不仅可以解决线程同步，还可以防止反序列化
 * @author travler100
 */
public enum Singleton_8 {
    INSTANCE;

    /**
     * for test
     */
    public static void main(String[] args) {
        //同一个类的不同对象的hashcode不同
        //跑100个线程，看看有没有不同的实例
        for (int i = 0; i < 100; i++) {
            new Thread(() -> System.out.println(Singleton_8.INSTANCE.hashCode())).start();
        }
    }
}