单例模式 - Singleton Patterns

Posted 有且仅有

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了单例模式 - Singleton Patterns相关的知识,希望对你有一定的参考价值。

父博文地址:设计模式 - Design Patterns


一、单例模式的意义

Design Patterns 一书中对单例模式描述:

Ensure a class only has one instance, and provide a global point of access to it.
确保一个Class只有一个实例,并对外提供一个全局访问点。

单例模式是最容易理解的设计模式。道理简单,不过如何写出一个“正确”的单例模式一开始并不简单。Talk is cheap. Show me the code.

单例模式的代码有两种不同的方式,一种被叫做所谓的“饿汉式”,另一种叫“懒汉式”。


二、饿汉方式

饿汉的意思是:急切的……,即急切的创建实例。代码如下:

/**
 * “饿汉式”,即“急切的方式”。
 */
public class Singleton 

    private static Singleton instance = new Singleton();

    private Singleton() 

    public static Singleton getInstance() 
        return instance;
    
  • 优点:实现简单、线程安全,JVM保证在任何线程能访问instance之前,实例化new Singleton()已被执行完成。

  • 缺点:如果实例化new Singleton()很耗资源,而对象在很久之后才会被用到或者本次程序运行中都用不到,则浪费了系统资源。


三、懒汉方式(懒加载)

针对“急切方式”的缺点,可以使用这种称为“懒加载”的方式来实现单例模式。

1. 第一遍代码:错误代码1

/**
 * 懒汉式,错误代码1
 * <p>
 * 错误原因:线程不安全。安全写法见$@link LazyInitializationCorrect
 * </p>
 */
public class LazyInitializationError 

    private static LazyInitializationError instance;

    private LazyInitializationError() 

    public static LazyInitializationError getInstance() 
        if (instance == null) 
            instance = new LazyInitializationError();
        
        return instance;
    

错误发生流程:

  1. 线程Thread1执行完if (instance == null)后失去了CPU执行权。
  2. 线程Thread2再次执行了if (instance == null)并得到true,然后它也失去执行权。
  3. Thread1恢复执行,实例化了一个对象并赋值给了instancereturn给调用方。
  4. Thread2恢复执行,它不知道instance已经不为null,所以会再次实例化一个新对象并return给调用方。

2. 第二遍代码:有性能损耗

/**
 * 懒汉式,性能有损耗
 */
public class LazyInitializationSlowly 
    private static LazyInitializationSlowly instance;

    private LazyInitializationSlowly ()

    public static synchronized LazyInitializationSlowly getInstance() 
        if (instance == null) 
            instance = new LazyInitializationSlowly();
        
        return instance;
    

缺点:每次调用getInstance()都需要先获取锁,造成资源损耗。

3. 第三遍代码:错误代码2

使用Double-checked locking 可以避免效率降低,请看以下代码。不过注意:下面代码其实仍有问题,具体在注释中。

/**
 * 懒汉式,错误代码2
 *
 * <p>
 * 使用了“Double-checked locking”,但不幸的是,在Java环境下注意这是又一个错误的写法,错误描述见代码注释
 * <br>安全写法见$@link LazyInitializationCorrect
 * </p>
 */
public class LazyInitializationErrorNoVolatile 

    private static LazyInitializationErrorNoVolatile instance;

    private LazyInitializationErrorNoVolatile() 

    /**
    * Double-checked locking
    */
    public static LazyInitializationErrorNoVolatile getInstance() 
        // first check 第一次检查并不会尝试获取锁,避免了性能损耗
        if (instance == null) 
            synchronized (LazyInitializationErrorNoVolatile.class) 
                // double check
                if (instance == null) 
                    instance = new LazyInitializationErrorNoVolatile();
                    // 一、上面这句代码在JVM中被分解为3个指令
                    // 1. 为对象分配内存空间(例如内存地址为:10001)。
                    // 2. 调用构造函数初始化对象。
                    // 3. 局部变量instance 指向对象被分配的内存空间。(即10001,执行完这步后instance 非null )

                    // 二、问题:
                    // 由于JVM的JIT编译器存在着称为“指令重排序”的优化行为,所以上面这行代码的指令执行顺序并非一定是“1-2-3”,
                    // 有可能被优化为“1-3-2”,这在Java内存模型中是完全合法的。所以错误出现在:
                    // 1. Thread1执行指令的顺序为“1-3-2”且在执行了“1-3”后丢失了CPU的执行权,此时3已执行所以instance为非null;
                    // 2. Thread2获取执行权,当执行到first check 时,发现结果为false所以直接return instance,然而此时instance指向的对象并没有初始化完成,随即程序可能崩溃。

                    // 三、解决问题:
                    // JDK1.5后volatile的语义被扩展了,使用volatile关键字即可解决。
                    // volatile的一个语义是:阻止指令重排序优化,使得上面执行的顺序必须是“1-2-3”即可。
                
            
        
        return instance;
    

4. 第四遍代码:正确写法

即上例代码的有volatile版本。

/**
 * 懒汉式,正确写法
 */
public class LazyInitializationCorrect 

    private static volatile LazyInitializationCorrect instance;

    private LazyInitializationCorrect() 

    public static LazyInitializationCorrect getInstance() 
        // Double-checked locking
        if (instance == null) 
            synchronized (LazyInitializationCorrect.class) 
                if (instance == null) 
                    instance = new LazyInitializationCorrect();
                
            
        
        return instance;
    

四、另一种正确的懒加载

懒加载还有一种效率更高的正确写法叫 Initialization-on-demand holder idiom,这种方式效率很高因为没有同步代码,当然它也有一定的局限性,这些在注释中详细的写了出来:

/**
 * 懒汉式,使用Hodler方式
 *
 * <p>完全线程安全,“Initialization-on-demand holder idiom”,但有一定限制</p>
 */
public class LazyInitializationCorrectWithHolder 

    private LazyInitializationCorrectWithHolder() 

    // 1. LazyInitializationCorrectWithHolder被JVM加载时,如果Holder类没被任何代码引用到的话,是不会被加载的,所以这里满足了“懒”;
    private static class Holder 
        private static final LazyInitializationCorrectWithHolder INSTANCE = new LazyInitializationCorrectWithHolder();
    

    public static LazyInitializationCorrectWithHolder getInstance() 
        // 2. 当外部代码调用 getInstance() 时,Holder才会被加载并执行;
        // 3. 又由于JVM保证了class的初始化是按照既定顺序的,不会多线程的,所以 INSTANCE 的初始化是线程安全的。
        return Holder.INSTANCE;
    

    // 4. 使用这种风格的单例,必须满足一个条件,构造函数的过程不能发生异常导致初始化失败。(double checked方式没有这个限制)
    // 错误代码如下,当初始化失败后,其它线程也不能再次完成初始化了,因为会一直发生LazyInitializationCorrectWithHolder$Holder NoClassDefFoundError
    // private LazyInitializationCorrectWithHolder() 
    //     if (Thread.currentThread().getName().equals("Threadddd-0")) 
    //         int i = 1/0;
    //     
    // 
    // public static void main(String[] args) 
    //     for (int i = 0; i < 3; i++) 
    //         final Thread thread = new Thread(new Runnable() 
    //             @Override
    //             public void run() 
    //                 getInstance();
    //             
    //         );
    //         thread.setName("Threadddd-" + i);
    //         thread.start();
    //     
    // 

单例模式很简单,不过如果你一开始无法预料到一些潜在的问题,其实也很难写出正确的代码。看过了这篇文章,相信你再也写不错了。


转载注明出处:http://blog.csdn.net/u010297957/article/details/70544003

以上是关于单例模式 - Singleton Patterns的主要内容,如果未能解决你的问题,请参考以下文章

[翻译] 单例(Singleton)

单例模式(Singleton) 2

单例模式(singleton)

单例模式(singleton)

Singleton Pattern (单例模式)

java设计模式学习 ----- 单例模式(Singleton)