JAVA单例（Singleton）实现的几种方式（多线程安全）

smartlion 发布于2019-08-15 17:47 / 1337人阅读

摘要：缺点每次调用都有线程开销延迟初始化单例默认构造方法为，避免用户用构造出新对象获取单例的静态工厂同步方法延迟初始化单例使用同步方法保证多线程操作只实例化一个实力单例模式。

主要分为两种：

直接初始化

延迟初始化

直接初始化 直接初始化final静态成员

线程安全：JVM保证final静态成员只会被初始化一次

公有静态成员是个final域，直接引用成员获取单例

/**
 * 公有静态成员是个final域
 * 直接引用成员获取单例
 */
public class Singleton1 {
    public static final Singleton1 INSTANCE = new Singleton1();

    /**
     * 默认构造方法为private，避免用户用new构造出新对象
     */
    private Singleton1() {}

    public void someMethod() {}

    public static void main(String[] args) {
        Singleton1.INSTANCE.someMethod();
    }
}

公有的成员是个静态工厂方法，通过该方法获取单例。

提供了灵活性，在不改变API的前提下，可以改变该类是否应该为单例的想法。
比如改成为每个调用该方法的线程返回一个唯一的实例(ThreadLocal)

/**
 * 公有的成员是个静态工厂方法，通过该方法获取单例
 */
public class Singleton2 {
    private static final Singleton2 INSTANCE = new Singleton2();
    /**
     * 默认构造方法为private，避免用户用new构造出新对象
     */
    private Singleton2() {}

    /**
     * 获取单例的静态工厂方法
     * @return Singleton2 单例
     */
    public static Singleton2 getInstance() { return INSTANCE; }

    public void someMethod() {}

    public static void main(String[] args) {
        Singleton2.getInstance().someMethod();
    }
}

包含单个元素的枚举类型(enum)

由枚举类型的性质保证枚举常量INSTANCE是唯一实例

/**
 * 一个包含单个元素的枚举类型
 * 枚举类型保证每个枚举常量都是一个单例
 */
public enum EnumSingleton {
    INSTANCE;
    public void someMethod() { /** .... */}

    public static void main(String[] args) {
        EnumSingleton.INSTANCE.someMethod();
    }
}

延迟初始化 直接在静态工厂方法上加 synchronized。缺点：每次调用都有线程开销

/**
 * 延迟初始化单例
 */
public class LazyInitSingleton1 {
    private static LazyInitSingleton1 INSTANCE;
    /**
     * 默认构造方法为private，避免用户用new构造出新对象
     */
    private LazyInitSingleton1() {}

    /**
     * 获取单例的静态工厂同步方法
     * 延迟初始化单例
     * 使用同步方法保证多线程操作只实例化一个实力
     * @return LazyInitSingleton1 单例
     */
    public synchronized static LazyInitSingleton1 getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazyInitSingleton1();
        }

        return INSTANCE;
    }

    public void someMethod() {}

    public static void main(String[] args) {
        Singleton2.getInstance().someMethod();
    }
}

lazy initialization holder class 模式。（参考《Effective Java》第71条：慎用延迟初始化

优点：避免同步方法的开销。
getInstance第一次被调用时，读取SingletonHolder.field，导致SingletonHolder类得到初始化

/**
 * lazy initialization holder class 模式
 * 避免同步方法的开销
 */
public class LazyInitSingleton2 {
    private static class SingletonHolder {
        static final LazyInitSingleton2 field = computeFieldValue();
        private static LazyInitSingleton2 computeFieldValue() {
            return new LazyInitSingleton2();
        }
    }

    private LazyInitSingleton2() {}
    public static LazyInitSingleton2 getInstance() {
        return SingletonHolder.field;
    }
}

双重检测，降低同步方法开销。（参考《Effective Java》第71条：慎用延迟初始化）

INSTANCE 使用 volatile 修饰符：防止JVM的即时编译器对INSTANCE = new LazyInitSingleton3()操作进行指令重排序。

/**
 * 延迟初始化，双重检测，降低同步方法开销
 */
public class LazyInitSingleton3 {
    /**
     * 注意：使用了 volatile 修饰符
     */
    private static volatile LazyInitSingleton3 INSTANCE;
    private LazyInitSingleton3() {}
    public static LazyInitSingleton3 getInstance() {
        // 第一次判断无需同步，如果 INSTANCE 已经被初始化，
        // 就直接返回，没有同步开销
        if (INSTANCE == null) {
            // 如果判断为空（多线程并发执行 getInstance，导致很多线程判断外层INSTANCE == NULL）
            synchronized (LazyInitSingleton3.class) {
                // 进入同步后再判断一次，
                // 保证只有一个线程赋值给 INSTANCE，
                // 后续进来执行的线程都会判断 INSTANCE != NULL，不会再赋值
                if (INSTANCE == null) {
                    INSTANCE = new LazyInitSingleton3();
                }
            }
        }

        return INSTANCE;
    }
}

为什么INSTANCE要使用volatile修饰符

在JVM中，new操作做了下面3件事：

给要new的对象LazyInitSingleton3分配内存空间

调用LazyInitSingleton3的构造函数来初始化对象

将INSTANCE指向步骤1中分配的内存空间

由于JVM存在指令重排序的优化，上面第2步和第3步顺序是无法保证的（1-2-3或者1-3-2）。
如果执行步骤是1-3-2，那么假设线程A执行到第3步，但第2步还未执行，此时线程B调用getInstance()发现INSTANCE非空（但未被初始化），直接返回INSTANCE，之后线程B对INSTANCE操作可能会发生错误（由于对象还未被初始化）。
volatile修饰符防止指令重排序的优化，保证执行顺序是1-2-3。

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/69447.html

深入理解单例模式

摘要：总结我们主要介绍到了以下几种方式实现单例模式饿汉方式线程安全懒汉式非线程安全和关键字线程安全版本懒汉式双重检查加锁版本枚举方式参考设计模式中文版第二版设计模式深入理解单例模式我是一个以架构师为年之内目标的小小白。初遇设计模式在上个寒假，当时把每个设计模式过了一遍，对设计模式有了一个最初级的了解。这个学期借了几本设计模式的书籍看，听了老师的设计模式课，对设计模式算是有个更进一步的认识。...

FuisonDesign 2019-08-15 17:54 评论0 收藏0
设计模式：单例模式 (关于饿汉式和懒汉式)

摘要：在写单例模式的代码之前，我们先简单了解一下两个知识点，关于类的加载顺序和关键字。懒汉和饿汉在程序编写上，一般将单例模式分为两种，分别是饿汉式和懒汉式，饿汉式在类加载时就完成了初始化，所以类加载比较慢，但获取对象的速度快。定义单例模式是比较常见的一种设计模式，目的是保证一个类只能有一个实例，而且自行实例化并向整个系统提供这个实例，避免频繁创建对象，节约内存。单例模式的应用场景很多，比如...

Darkgel 2019-05-23 16:22 评论0 收藏0
设计模式系列之单例模式

摘要：下面我们来看看看中的单例模式，中使用的是单例注册表的特殊方式实现的单例模式，所以说模式是死的，需要灵活得运用。本文循序渐进介绍单例模式的几种实现方式，以及Jdk中使用到单例模式的例子，以及sring框架中使用到的单例模式例子。饿汉式 package signgleton; /** * 单例模式简单的实现 */ public class Singleton { priv...

Jason 2019-08-16 18:24 评论0 收藏0
Java设计模式---单例模式

摘要：单例模式的几种实现方法具体如下懒汉模式优点可以延迟加载缺点多线程不安全饿汉模式优点多线程安全缺点加载类时就初始化完成无法延时加载双重检查优点多线程安全延迟加载缺点同步耗时静态内部类优点多线程安全延迟加载耗时短与双重检查相比用缓存实现优 showImg(http://7xjhi6.com1.z0.glb.clouddn.com/Java-Design-Patterns-Logo.png)...

klivitamJ 2019-08-14 15:16 评论0 收藏0
单例模式的几种写法

摘要：单例模式要点私有的构造方法指向实例的私有静态引用获取实例对象的公有静态方法饿汉模式非线程安全私有化构造函数懒汉模式非线程安全私有化构造函数双重线程锁检查单例线程安全私有化构造函数枚举单例更多关于的文章请戳这里您的留言意见是对我最大的支持我的单例模式要点私有的构造方法指向实例的私有静态引用获取实例对象的公有静态方法饿汉模式（非线程安全） public class Singl...

Youngs 2019-08-14 18:02 评论0 收藏0