当前位置:首页 > 开发 > 行业应用 > 正文

单例(Singleton)模式

发表于: 2014-04-25   作者:aoyouzi   来源:转载   浏览:
摘要: 3.1           概述 如果要保证系统里一个类最多只能存在一个实例时,我们就需要单例模式。这种情况在我们应用中经常碰到,例如缓存池,数据库连接池,线程池,一些应用服务实例等。在多线程环境中,为了保证实例的唯一性其实并不简单,这章将和读者一起探讨如何实现单例模式。 3.2

3.1           概述 
如果要保证系统里一个类最多只能存在一个实例时,我们就需要单例模式。这种情况在我们应用中经常碰到,例如缓存池,数据库连接池,线程池,一些应用服务实例等。在多线程环境中,为了保证实例的唯一性其实并不简单,这章将和读者一起探讨如何实现单例模式。 
3.2           最简单的单例 
为了限制该类的对象被随意地创建,我们保证该类构造方法是私有的,这样外部类就无法创建该类型的对象了;另外,为了给客户对象提供对此单例对象的使用,我们为它提供一个全局访问点,代码如下所示: 
public class Singleton { 
    private static Singleton instance = new Singleton();   
    //other fields… 

    private Singleton() { 
    } 

    public static Singleton getInstance() { 
        return instance; 
    } 
   
    //other methods… 

代码注解: 
l      Singleton类的只有一个构造方法,它是被private修饰的,客户对象无法创建该类实例。 
l      我们为此单例实现的全局访问点是public static Singleton getInstance()方法,注意,instance变量是私有的,外界无法访问的。 
读者还可以定义instance变量是public的,这样把属性直接暴露给其他对象,就没必要实现public static Singleton getInstance()方法,但是可读性没有方法来的直接,而且把该实例变量的名字直接暴露给客户程序,增加了代码的耦合度,如果改变此变量名称,会引起客户类的改变。 

还有一点,如果该实例需要比较复杂的初始化过程时,把这个过程应该写在static{…}代码块中。 
l      此实现是线程安全的,当多个线程同时去访问该类的getInstance()方法时,不会初始化多个不同的对象,这是因为,JVM(Java Virtual Machine)在加载此类时,对于static属性的初始化只能由一个线程执行且仅一次[1]。 
由于此单例提供了静态的公有方法,那么客户使用单例模式的代码也就非常简单了,如下所示: 
Singleton singleton = Singleton.getInstance(); 
3.3           进阶 
3.3.1           延迟创建 
如果出于性能等的考虑,我们希望延迟实例化单例对象(Static属性在加载类是就会被初始化),只有在第一次使用该类的实例时才去实例化,我们应该怎么办呢? 

这个其实并不难做到,我们把单例的实例化过程移至getInstance()方法,而不在加载类时预先创建。当访问此方法时,首先判断该实例是不是已经被实例化过了,如果已被初始化,则直接返回这个对象的引用;否则,创建这个实例并初始化,最后返回这个对象引用。代码片段如下所示: 
public class UnThreadSafeSingelton { 
    //variables and constructors… 

    public static UnThreadSafeSingelton getInstance() { 
        if(instatnce ==null){ 
          instatnce = new UnThreadSafeSingelton(); 
        } 
        return instatnce; 
    } 

我们使用这句if(instatnce ==null) 判断是否实例化完成了。此方法不是线程安全的,接下来我们将会讨论。 
3.3.2           线程安全 
上节我们创建了可延迟初始化的单例,然而不幸的是,在高并发的环境中,getInstance()方法返回了多个指向不同的该类实例,究竟是什么原因呢?我们针对此方法,给出两个线程并发访问getInstance()方法时的一种情况,如下所示: 
    t1                                                                           t2 
1   if(instatnce ==null)    
2                                                                      if(instatnce ==null) 
3   instatnce = new UnThreadSafeSingelton();    
4   return instatnce;      
5                                                                            instatnce = new UnThreadSafeSingelton() 
6                                                                            return instatnce; 


如果这两个线程按照上述步骤执行,不难发现,在时刻1和2,由于还没有创建单例对象,Thread1和Thread2都会进入创建单例实例的代码块分别创建实例。在时刻3,Thread1创建了一个实例对象,但是Thread2此时已无法知道,继续创建一个新的实例对象,于是这两个线程持有的实例并非为同一个。更为糟糕的是,在没有自动内存回收机制的语言平台上运行这样的单例模式,例如使用C++编写此模式,因为我们认为创建了一个单例实例,忽略了其他线程所产生的对象,不会手动去回收它们,引起了内存泄露。 

为了解决这个问题,我们给此方法添加synchronized关键字,代码如下: 
public class ThreadSafeSingelton { 
    //variables and constructors… 

    public static synchronized ThreadSafeSingelton getInstance() { 
        if(instatnce ==null){ 
            instatnce = new ThreadSafeSingelton(); 
        } 
        return instatnce; 
    } 

这样,再多的线程访问都只会实例化一个单例对象。 
3.3.3           Double-Check Locking 
上述途径虽然实现了多线程的安全访问,但是在多线程高并发访问的情况下,给此方法加上synchronized关键字会使得性能大不如前。我们仔细分析一下不难发现,使用了synchronized关键字对整个getInstance()方法进行同步是没有必要的:我们只要保证实例化这个对象的那段逻辑被一个线程执行就可以了,而返回引用的那段代码是没有必要同步的。按照这个想法,我们的代码片段大致如下所示: 
public class DoubleCheckSingleton { 
    private volatile static DoubleCheckSingleton instatnce = null; 

    //constructors 

    public static DoubleCheckSingleton getInstance() { 
        if (instatnce == null) {   //check if it is created. 
            synchronized (DoubleCheckSingleton.class) {  //synchronize creation block 
                if (instatnce == null)   //double check if it is created 
                    instatnce = new DoubleCheckSingleton(); 
            } 
        } 
        return instatnce; 
    } 

代码注解: 
l      在getInstance()方法里,我们首先判断此实例是否已经被创建了,如果还没有创建,首先使用synchronized同步实例化代码块。在同步代码块里,我们还需要再次检查是否已经创建了此类的实例,这是因为:如果没有第二次检查,这时有两个线程Thread A和Thread B同时进入该方法,它们都检测到instatnce为null,不管哪一个线程先占据同步锁创建实例对象,都不会阻止另外一个线程继续进入实例化代码块重新创建实例对象,这样,同样会生成两个实例对象。所以,我们在同步的代码块里,进行第二次判断判断该对象是否已被创建。 

正是由于使用了两次的检查,我们称之为double-checked locking模式。 
l      属性instatnce是被volatile修饰的,因为volatile具有synchronized的可见性特点,也就是说线程能够自动发现volatile变量的最新值。这样,如果instatnce实例化成功,其他线程便能立即发现。 
注意: 
此程序只有在JAVA 5及以上版本才能正常运行,在以前版本不能保证其正常运行。这是由于Java平台的内存模式容许out-of-order writes引起的,假定有两个线程,Thread 1和Thread 2,它们执行以下步骤: 
1.     Thread 1发现instatnce没有被实例化,它获得锁并去实例化此对象,JVM容许在没有完全实例化完成时,instance变量就指向此实例,因为这些步骤可以是out-of-order writes的,此时instance==null为false,之前的版本即使用volatile关键字修饰也无效。 
2.     在初始化完成之前,Thread 2进入此方法,发现instance已经不为null了,Thread 2便认为该实例初始化完成了,使用这个未完全初始化的实例对象,则很可能引起系统的崩溃。 
3.3.4           Initialization on demand holder 
要使用线程安全的延迟的单例初始化,我们还有一种方法,称为Initialization on demand holder模式,代码如下所示: 
public class LazyLoadedSingleton { 
    private LazyLoadedSingleton() { 
       } 

       private static class LazyHolder {  //holds the singleton class 
              private static final LazyLoadedSingleton singletonInstatnce = new LazyLoadedSingleton(); 
       } 

       public static LazyLoadedSingleton getInstance() { 
              return LazyHolder.singletonInstatnce; 
       } 

当JVM加载LazyLoadedSingleton类时,由于该类没有static属性,所以加载完成后便即可返回。只有第一次调用getInstance()方法时,JVM才会加载LazyHolder类,由于它包含一个static属性singletonInstatnce,所以会首先初始化这个变量,根据前面的介绍,我们知道此过程并不会出现并发问题(JLS保证),这样即实现了一个既线程安全又支持延迟加载的单例模式。 
3.3.5           Singleton的序列化 
如果单例类实现了Serializable接口,这时我们得特别注意,因为我们知道在默认情况下,每次反序列化(Desierialization)总会创建一个新的实例对象,这样一个系统会出现多个对象供使用。我们应该怎么办呢? 

熟悉Java序列化的读者可能知道,我们需要在readResolve()方法里做文章,此方法在反序列化完成之前被执行,我们在此方法里替换掉反序列化出来的那个新的实例,让其指向内存中的那个单例对象即可,代码实现如下: 
import java.io.Serializable; 

public class SerialibleSingleton implements Serializable { 
    private static final long serialVersionUID = -6099617126325157499L; 
    static SerialibleSingleton singleton = new SerialibleSingleton(); 

    private SerialibleSingleton() { 
    } 

    // This method is called immediately after an object of this class is deserialized. 
    // This method returns the singleton instance. 
    private Object readResolve() { 
        return singleton; 
    } 

方法readResolve()直接返回singleton单例,这样,我们在内存中始终保持了一个唯一的单例对象。

单例(Singleton)模式

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
首先来明确一个问题,那就是在某些情况下,有些对象,我们只需要一个就可以了, 比如,一台计算机上
单例(Singleton)模式 单例(Singleton)模式: 保证一个类在系统里只能有一个对象被实例化。 如:
1 package com.fairy.dp.singleton; public class Singleton { /** * 类级的内部类,也就是静态的成
重点概念 1. 所有类都有构造方法,不编码则系统默认生成空的构造方法,若有显示定义的构造方法,默
单例模式 Singletonn Pattern Ensure a class has only one instance, and provide a global point
首先我们先看看一个例子,在说什么是单利模式(Singleton): package org.bestupon.dp.singleton; /**
0.前言 在一年多前就开始学习设计模式了,主要看的是GoF的那本书《设计模式-可复用面向对象软件的基
一、引入 有一些对象其实我们只需要一个,比如线程池,缓存,对话框注册表的对象,日志对象等。事实
Singleton pattern的思想: 一个类能返回对象的一个引用(永远是同一个)和一个获得该实例的方法(必
1.定义 保证一个类仅有一个实例,并提供一个访问它的全局访问点。 2. 单例模式的本质:控制实例数目
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号