专栏首页JavaJourney【设计模式】各个击破单例模式的8种写法

【设计模式】各个击破单例模式的8种写法

曲径通幽处,禅房花木深。

单例模式

在一个系统开发过程中,我们在基于节省内存资源、保证数据内容的一致性的考虑上,往往需要对某些类要求只能创建一个实例,即「保证类只有一个实例」的设计模式就是单例模式。

比如我们遇到过的各种Manager管理类,各种Factory工厂类;

Spring 框架应用中的 ApplicationContext、数据库中的连接池等也都是单例模式。

本文旨在浅析一下单例模式的写法。

单例模式的8种写法

1. 饿汉式

/**
 * 类加载的时候就实例化一个实例,JVM保证线程安全
 * 也称饿汉式
 * 该方式简单实用
 * @author 行百里er
 */
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 行百里er
 */
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);
    }
}

和第一种写法是同一个意思,只是将new的动作放在了代码块里,类加载到内存的时候只加载一个实例。

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

/**
 * 懒汉式
 * 这种写法虽然达到了用的时候才初始化的目的,但是存在多线程获取实例时相互影响的问题
 * @author 行百里er
 */
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 行百里er
 */
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. 那就在线程安全的基础上减少锁住的代码数量,「这里有坑」

/**
 * lazy loading 懒汉式
 * 在加锁的基础上再优化一下,减少加锁代码块的数量
 * @author 行百里er
 */
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. 那就来个双重检查锁(Double Check Locking)吧

/**
 * 在加锁的基础上再优化一下,减少加锁代码块的数量---事实证明不可行
 * 那就双重检查DCL
 * @author 行百里er
 */
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 是static的):

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

既然有值了,那么线程B上来先进行检查发现已经有值,就不会进入加锁那部分的代码了。

加了「volatile」后,就不允许指令重排序了。所以此时一定是保证线程A初始化完了才会复制给这个变量。

7. 静态内部类方式

/**
 * 静态内部类方式
 * JVM保证单例
 * 加载外部类时不会加载内部类---也可实现懒加载
 * @author 行百里er
 */
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实现单例

/**
 * 枚举单例
 * 不仅可以解决线程同步,还可以防止反序列化
 */
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();
        }
    }
}

膜拜一波这种写法!这是Java创始人之一的大神在《Effective Java》这本书中推荐的写法。

小结

虽然单例模式有这么多种写法,但不少是炫技式的花活,有点像孔乙己的“茴”字的N中写法。

这里我们理解其中有些写法的“瑕疵”和其中蕴含的“原理”就可以了。

好了,本地导航就到这里。

文章分享自微信公众号:
行百里er

本文参与 腾讯云自媒体分享计划 ,欢迎热爱写作的你一起参与!

作者:行百里er
原始发表时间:2020-12-08
如有侵权,请联系 cloudcommunity@tencent.com 删除。
登录 后参与评论
0 条评论

相关文章

  • 设计模式【1】-- 单例模式到底几种写法?

    单例模式,是一种比较简单的设计模式,也是属于创建型模式(提供一种创建对象的模式或者方式)。要点:

    秦怀杂货店
  • 设计模式【1】-- 单例模式到底几种写法?

    单例模式,是一种比较简单的设计模式,也是属于创建型模式(提供一种创建对象的模式或者方式)。

    秦怀杂货店
  • 单例模式【单例设计模式】

    指一个类只有一个实例,且该类能自行创建这个实例的一种模式。例如,Windows 中只能打开一个任务管理器,这样可以避免因打开多个任务管理器窗口而造成内存资源的浪...

    高大北
  • 单例模式的正确写法

    单例模式可能是代码最少的模式了,但是少不一定意味着简单,想要用好、用对单例模式,还真得费一番脑筋。本文对Java中常见的单例模式写法做了一个总结,如有错漏之处,...

    用户1212940
  • 设计模式——单例模式

    关于单例模式,这是面试时最容易遇到的问题。当时以为很简单的内容,深挖一下,也可以关联出类加载、序列化等知识。

    健程之道
  • 设计模式 - 单例模式

    单例模式属于创建型模式,是设计模式中比较简单的模式。在单例模式中,单一的类负责创建自己的对象,同时确保只有单个对象被创建。保证一个类仅有一个实例,并提供一个访问...

    希希里之海
  • 设计模式-单例模式

    许多时候整个系统只需要拥有一个全局对象,这样有利于我们协调系统整体的行为。实际场景又哪些?如下

    码哥字节
  • 【设计模式-单例模式】

    今天来说一下同样属于创建型模式的单例模式,相信这个模式普遍都清楚,因为平时在编码的时候都会进行相应的使用,我这边就当做日志记录一下。免得以后忘了还得去搜,我发现...

    Liusy
  • 设计模式 - 单例模式

    不管怎么跑都是一个,但是 LazyMan = new LazyMan();在极端情况下是有问题的,因为他不是一个原子性操作。

    断痕
  • 设计模式:单例模式

    今天来简单来说一下单例模式:它要确保一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。 比如我们登录一个系统的时候要记录一个员工的信息,在整个系统运行...

    lpxxn
  • 单例模式(下)---聊一聊单例模式的几种写法

    在上一篇文章 单例模式(上)---如何优雅地保证线程安全问题中,我们采取了懒汉式写法来写我们的单例模式,并且重点讲解了懒汉式中线程安全的问题。这篇我们来讲讲单例...

    帅地
  • 设计模式 --单例模式

    用户5166556
  • 设计模式---单例模式

    当一个Java类第一次被真正使用到的时候静态资源被初始化、Java类的加载和初始化过程都是线程安全的

    大忽悠爱学习
  • 设计模式—单例模式

    例如在Java开发中,我们都知道类和对象实例可以通过new来创建一个或者多个,而单例模式就是采取一定的办法保证整个系统中某一个类只能存在唯一一个对象实例,并且获...

    乌龟哥哥
  • 【设计模式】单例设计模式

    单例模式可以说是整个设计中最简单的模式之一,而且这种方式即使在没有看设计模式相关资料也会常用在编码开发中。

    Li_XiaoJin
  • 设计模式--单例模式

    用户5927264
  • 设计模式-单例模式

    单列模式是创建型模式的一种,同样一个对象(实例)在内存中只会有一份,并只有一个全局的访问点。单列分为好多种实现,其中有线程安全和线程不安全,大类有懒汉和饿汉;

    逍遥壮士
  • 【设计模式】单例模式

    前几天面试一个校招的小朋友,让他写单例模式,没写出来,所以这里把两年前我的学习笔记发一下。这应该是所有设计模式中最简单的设计模式了,从它讲起。

    Leetcode名企之路
  • 设计模式----单例模式

    SuperHeroes

扫码关注腾讯云开发者

领取腾讯云代金券