`
liuliu140
  • 浏览: 6311 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

单例模式的几种实现方式以及优缺点

    博客分类:
  • java
 
阅读更多

转:http://blog.chenzuhuang.com/archive/13.html

 

 

背景

单例模式是一种常用的软件设计模式,常被用于一个类在系统中最多只允许存在一个实例的场合,如窗口管理器、打印缓冲池、文件系统等。在单例模式的核心结构中,只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问,从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个,单例模式是最好的解决方案。在Java中,单例模式如此定义:“一个类有且仅有一个实例,并且自行实例化向整个系统提供。”简而言之,单例模式就是保证一个类最多只能存在一个实例对象

 

 

懒汉式

顾名思义,lazy loading(延迟加载,一说懒加载),在需要的时候才创建单例对象,而不是随着软件系统的运行或者当类被加载器加载的时候就创建。当单例类的创建或者单例对象的存在会消耗比较多的资源,常常采用lazy loading策略。这样做的一个明显好处是提高了软件系统的效率,节约内存资源。下面我们看看最简单的懒汉单例模式:

代码1-1

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Singleton {
    private static Singleton singleton = null;    //私有的、类型为Singleton
//自身的静态成员变量
     
    //构造方法被设为私有,防止外部使用new来创建对象,破坏单例
    private Singleton(){
        System.out.println("构造函数被调用");
    }
     
    //公有的静态方法,供外部调用来获取单例对象
    public static Singleton getInstance(){
        if(singleton == null){    //第一次调用该方法时,创建对象。
            singleton = new Singleton();
        }
        return singleton;
    }
}

 

在单线程环境下,多次调用getInstance()方法获得的Singleton对象均为同一个对象,单例模式实现成功。然而,在更多时候,软件系统工作于多线程环境下,因此不得不考虑线程安全的问题。

现有多线程测试程序如下:

代码1-2

?

1
2
3
4
5
6
7
8
9
10
public class TestThread {
    public static void main(String[] args) {
        Runnable run = () -> Singleton.getInstance();    //创建实现了Runnable
// 接口的匿名类
        for(int i = 0; i < 50; i++){
            Thread thread = new Thread(run);
            thread.start();
        }
    }
}

 

代码中先创建了一个实现了Runnable接口的匿名类对象run,然后用for循环创建并启动50个线程,其中一次运行结果如下:

?

1
2
3
4
构造函数被调用
构造函数被调用
构造函数被调用
构造函数被调用

 

显然,Singleton的构造方法不止一次被调用,也就是说,Singleton存在四个实例对象,这违背了单例模式的初衷。这个实验说明,简单的懒汉式在多线程环境下不是线程安全的。有人提出在getInstance()方法上同步锁,但是锁住一整个方法可能粒度过大,不利于效率。既然锁方法不太好,那么锁代码呢?下面我们再看看两个例子:

代码1-3

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Singleton {
    private static Singleton singleton = null;    
     
    private Singleton(){
        System.out.println("构造函数被调用");
    }
     
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class){
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

 

代码段1-3的getInstance()方法里,在判空语句后上锁,把singleton = new Singleton()语句锁住了,这样做看似解决了线程安全问题,其实不然。设现有线程A和B,在t1时刻线程A和B均已通过判空语句但都未取得锁资源;t2时刻时,A先取得锁资源进入临界区(被锁的代码块),执行new操作创建实例对象,然后退出临界区,释放锁资源。t3时刻,B取得被A释放的锁资源进入临界区,执行new操作创建实例对象,然后退出临界区,释放锁资源。明显地,Singleton被实例化两次。所以,如代码段1-3这样写也不能保证线程安全。

代码1-4

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Singleton {
    private static Singleton singleton = null;    
     
    private Singleton(){
        System.out.println("构造函数被调用");
    }
     
    public static Singleton getInstance(){
            synchronized(Singleton.class){
                if(singleton == null){
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

 

    代码段1-4把代码锁放在了判空语句前,这样做避免了代码段1-3的问题,然而这样做类似于在方法签名上加上synchronized关键字,会影响程序效率。因为当有多个线程几乎同时访问getInstance方法时,多个线程必须有次序地进入方法内,这样导致了若干个线程需要耗费等待进入临界区(被锁住的代码块)的时间。基于此,有人提出了双重校验锁式。

 

 

双重校验锁DCL(double checked locking)

双重校验锁式(也有人把双重校验锁式和懒汉式归为一类)分别在代码锁前后进行判空校验,避免了多个有机会进入临界区的线程都创建对象,同时也避免了代码段1-4后来线程在先来线程创建对象后但仍未退出临界区的情况下等待。双重校验锁代码如下:

代码2-1

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Singleton{
        private volatile static Singleton singleton = null;    //注意此处加上了
//volatile关键字    
    private Singleton(){
        System.out.println("构造函数被调用");
    }
     
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                    //return singleton;    //有人提议在此处进行一次返回
                }
                //return singleton;    //也有人提议在此处进行一次返回
            }
        }
        return singleton;
    }
}

 

经多次试验说明,双重校验锁式是线程安全的。然而,在JDK1.5以前,DCL是不稳定的,有时也可能创建多个实例,在1.5以后开始提供volatile关键字修饰变量来达到稳定效果。

 

对volatile关键字的特别说明:

有人认为使用volatile的原因是可见性,也就是可以保证线程在本地不会存有singleton副本,每次都是去主内存中读取,但是其实是不对的。使用volatile的主要原因是其另一个特性:禁止指令重排序优化。也就是说,在volatile变量的赋值操作后面会有一个内存屏障(生成的汇编代码上),读操作不会被重排序到内存屏障之前。比如上面的例子:其中,singleton = new Singleton()并非是原子操作,事实上在JVM中这句话做了三件事:

1.给singleton变量分配内存

2.调用Singleton的构造函数来初始化成员变量

3.将singleton引用指向分配的空间

但是在JVM的即时编译器中存在指令重排序的优化,也就是说上面的第二步和第三步是不能保证顺序的,最终执行的顺序可能是1-2-3或者是1-3-2。如果是后者,则在3执行完毕,2执行之前,被线程2抢占了,这时instance已经是非null了(但却没有初始化),所以线程2会直接返回singleton,然后使用,然后会报错。

 假设没有关键字volatile的情况下,两个线程A、B,都是第一次调用该单例方法,线程A先执行singleton = new Singleton(),该构造方法是一个非原子操作,编译后生成多条字节码指令,由于JAVA的指令重排序,可能会先执行singleton的赋值操作,该操作实际只是在内存中开辟一片存储对象的区域后直接返回内存的引用,之后singleton便不为空了,但是实际的初始化操作却还没有执行,如果就在此时线程B进入,就会看到一个不为空的但是不完整(没有完成初始化)的Singleton对象,所以需要加入volatile关键字,禁止指令重排序优化,从而安全的实现单例。

 

  • volatile变量规则:对一个变量的写操作先行发生于后面对这个变量的读操作:
  • singleton=new Singleton()相当于对volatile变量singleton的写操作
  • sychronized外面的if判断相当于对volatile变量singleton的读操作

 

 

饿汉式

单例模式的饿汉式,在定义自身类型的成员变量时就将其实例化,使得在Singleton单例类被系统(姑且这么说)加载时就已经被实例化出一个单例对象,从而一劳永逸地避免了线程安全的问题。代码如下:

代码3-1

?

1
2
3
4
5
6
7
8
9
10
11
public class Singleton{
        private static Singleton singleton = new Singleton();    //在定义变量
//将其实例化    
    private Singleton(){
        System.out.println("构造函数被调用");
    }
     
    public static Singleton getInstance(){
        return singleton;
    }
}

 

使用多线程测试代码1-2进行测试,单例模式成功实现。

我想应该有朋友对饿汉式单例在何时被实例化感兴趣。可以编写如下简单测试代码:

代码3-2

?

1
2
3
4
5
public class TestThread {
    public static void main(String[] args) {
        Class.forName("Singleton");
    }
}

 

运行这段代码后可以看到控制台有“构造函数被调用”字符串输出,说明在ClassLoader加载Singleton类时,饿汉式单例就被创建。

虽然饿汉式单例是线程安全的,但也有其不足之处。饿汉式单例在类被加载时就创建单例对象并且长驻内存,不管你需不需要它;如果单例类占用的资源比较多,就会降低资源利用率以及程序的运行效率。有一种更高级的单例模式则很好地解决了这个问题——静态内部类。

 

 

IoDH(Initialization Demand Holder)——通过静态内部类实现线程安全的单例模式

静态内部类式在Singleton类内部定义了一个静态的内部类,在该内部类里创建Singleton的单例对象。我们先看代码:

代码4-1

?

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Singleton {
    private Singleton(){
        System.out.println("构造函数被调用");
    }
     
    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
     
    private static class SingletonHolder{
        private static Singleton instance = new Singleton();
    }
}

 

静态内部类式和饿汉式一样,同样利用了ClassLoader的机制保证了线程安全;不同的是,饿汉式在Singleton类被加载时(从代码段3-2的Class.forName可见)就创建了一个实例对象,而静态内部类即使Singleton类被加载也不会创建单例对象,除非调用里面的getInstance()方法。因为当Singleton类被加载时,其静态内部类SingletonHolder没有被主动使用。只有当调用getInstance方法时,才会装载SingletonHolder类,从而实例化单例对象。

这样,通过静态内部类的方法就实现了lazy loading,很好地将懒汉式和饿汉式结合起来,既实现延迟加载,保证系统性能,也能保证线程安全

 

然而,对于上述四种方式的单例模式,如果你的Singleton类实现了Serializable序列化接口,那么可能会被序列化生成多个实例,因为readObject()方法一直返回一个新的对象:

?

1
2
3
4
5
6
ByteArrayOutputStream baos  = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(singleton);
  
ObjectInputStream ois =
new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
Singleton singleton=  (Singleton) ois.readObject();

 

这种情况可以通过在Singleton类添加readResolve()方法来解决:

?

1
2
3
4
private Object readResolve() {
        System.out.println("readResolve()被调用");
        return getInstance();
}

 

但是这种解决方案虽解决了序列化的问题,但是无法避免被反射。下面还有一种枚举单例,写法简单,还可以避免序列化、反射的问题。

 

 

枚举单例

上面说到的静态内部类方式不失为一个高级的单例模式实现。但如果开发要求更严格一些,比如你的Singleton类实现了序列化,又或者想避免通过反射来破解单例模式的话,单例模式还可以有另一种形式。那就是枚举单例。枚举类型在JDK1.5被引进。这种方式也是《Effective Java》作者Josh Bloch 提倡的方式,它不仅能避免多线程的问题,而且还能防止反序列化重新创建新的对象、防止被反射攻击。代码如下:

代码5-1

?

1
2
3
4
5
6
7
8
9
10
11
public enum EnumSingleton {
    INSTANCE{
        @Override
        protected void work() {
            System.out.println("你好,是我!");
        }
         
    };
     
    protected abstract void work();    //单例需要进行操作(也可以不写成抽象方法)
}

 

在外部,可以通过EnumSingleton.INSTANCE.work()来调用work方法。默认的枚举实例的创建是线程安全的,但是实例内的各种方法则需要程序员来保证线程安全。总的来说,使用枚举单例模式,有三个好处:1.实例的创建线程安全,确保单例。2.防止被反射创建多个实例。3.没有序列化的问题。

分享到:
评论

相关推荐

    JAVA单例模式的几种实现方法

    ### JAVA单例模式的几种实现方法 #### 一、饿汉式单例类 饿汉式单例类是在类初始化时就已经完成了实例化的操作。这种实现方式简单且线程安全,因为实例化过程是在编译期间完成的,不会受到多线程的影响。 **代码...

    单例模式各种实现方式

    以下是几种常见的单例模式实现方式: 1. **饿汉式(静态常量)**: 这是最简单的实现方式,它在类加载时就完成了初始化,因此是线程安全的。 ```java public class Singleton { private static final Singleton...

    7种单例模式

    单例模式是软件设计模式中的一种经典模式,其主要...总结起来,单例模式有多种实现方式,每种方式都有其适用场景和优缺点。在实际应用中,开发者应根据项目需求选择合适的单例实现,并注意线程安全和反序列化等问题。

    几种单例模式demo

    单例模式的实现方式有很多种,下面我们将详细探讨几种常见的单例模式的实现方法: 1. 饿汉式(静态常量): 这种方式在类加载时就完成了初始化,因此是线程安全的。 ```java public class Singleton { private ...

    java-单例模式几种写法

    以下是对这六种常见单例模式实现方式的详细解释: 1. **饿汉式(静态常量)** 这是最简单的单例实现,它在类加载时就创建了实例,线程安全。 ```java public class Singleton { private static final Singleton...

    几种单例模式说明(并有实例)

    根据给定的信息,本文将详细解释几种常见的单例模式,并通过具体的Java代码示例来阐述每种模式的特点和实现方式。 ### 单例模式简介 单例模式是一种常用的软件设计模式,它保证一个类只有一个实例,并提供一个全局...

    单例模式单例模式单例模式

    #### 二、单例模式的实现方式 ##### 1. 构造器私有化 要实现单例模式,最基础的方法是将类的构造器设置为`private`,这样外部就无法通过构造器来创建新的对象实例。这种做法保证了外部无法通过常规的方式创建对象...

    C++ 单例模式的几种实现方式研究

    "C++ 单例模式的几种实现方式研究" 单例模式是设计模式中最常应用的一种模式,也是面试官最喜欢的题目。但是,如果没有学过设计模式的人,可能不会想到要去应用单例模式,面对单例模式适用的情况。 单例模式的主要...

    设计模式之单例模式源码demo

    单例模式的实现方式有很多种,主要分为以下几种: 1. **饿汉单例模式**:在类加载时就完成初始化,因此静态变量`instance`会随着类的加载而被创建。这种方式线程安全,且因为单例在类加载时已经创建,所以不存在多...

    Python中的单例模式的几种实现方式的及优化

    本篇文章将深入探讨Python中实现单例模式的几种方式以及它们的优缺点和优化策略。 首先,Python的模块机制实际上天然地支持单例模式。当模块首次被导入时,解释器会执行模块中的所有代码,生成相应的`.pyc`文件。...

    C#单例模式详解 C#单例模式详解C#单例模式详解

    首先,实现C#单例模式通常有几种常见方法: 1. 饿汉式(静态常量): 这种方式在类加载时就完成了实例化,线程安全,但可能导致不必要的内存占用。 ```csharp public class Singleton { private static ...

    单例模式---初学 优点--缺点

    单例模式的实现通常包括以下几个关键点: 1. **私有化构造函数**:为了防止其他部分的代码通过常规方式创建类的实例,单例模式会将构造函数设为私有,这样外部就不能直接通过new关键字实例化对象。 2. **静态方法...

    Java单例模式深入理解

    在Java中,常见的单例模式实现方式有以下几种: 1. 饿汉式(静态常量): 这种实现方式在类加载时就完成了初始化,所以是线程安全的。代码如下: ```java public class Singleton { private static final ...

    设计模式-单例模式

    以上就是Java中常见的单例模式实现方式,每种方式都有其适用场景和优缺点。在实际开发中,应根据项目需求和环境选择合适的方法。例如,如果对性能要求较高,可能会选择静态内部类或枚举方式;如果需要考虑序列化问题...

    OC单例模式讲解

    ### OC单例模式讲解 #### 一、单例模式简介 单例模式是设计模式中的一种,属于创建型...通过本文的介绍,我们了解了单例模式的概念、实现方法以及其优缺点。希望这些内容能够帮助开发者更好地理解和应用单例模式。

    关于单例模式的知识要点

    下面我们将深入探讨单例模式的实现方式、优缺点以及在实际开发中的应用。 首先,单例模式的三个核心特性如描述中所提到: 1. **唯一实例**:在程序运行期间,单例类只能被实例化一次。这通常通过将构造函数设为私有...

    单例模式详解

    单例模式的实现主要有以下几种方式: 1. **饿汉式(静态常量)**:在类加载时即创建实例。 - 优点:无需加锁,执行效率高。 - 缺点:在系统启动时就占用内存,如果最终这个单例对象没有被使用,则会造成资源浪费...

    设计模式单例模式PPT学习教案.pptx

    两种实现方式都可以实现单例模式,但是它们有不同的优缺点。 单例模式是一种常用的设计模式,用于确保系统中只有一个实例存在,并提供了一个全局访问点来访问该实例。它可以应用于各种系统,如服务器负载均衡器、...

    常见设计模式-单例模式

    在Java编程中,实现单例模式有多种方式,每种方式都有其优缺点。 1. **饿汉式**: 饿汉式在类加载时即创建单例,因此是线程安全的,初始化速度快,内存占用小。但缺点是无论是否需要,单例都会在类加载时被创建,...

    单例模式概念与实例(简单实例)

    单例模式在实际开发中有着广泛的应用,不同的实现方式各有优缺点。开发者可以根据具体的应用场景选择最合适的实现方式。例如,对于资源消耗较大且不经常使用的对象,可以考虑使用懒汉式的实现;而对于需要频繁访问的...

Global site tag (gtag.js) - Google Analytics