单例模式之最终总结

1 单例模式的动机

 为了节约系统资源,有时需要确保系统中某个类只有唯一一个实例,当这个唯一实例创建成功之后,我们无法再创建一个同类型的其他对象,所有的操作都只能基于这个唯一实例。为了确保对象的唯一性,我们可以通过单例模式来实现,这就是单例模式的动机所在。

 

2 单例模式概述 

单例模式(Singleton Pattern):确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例,这个类称为单例类,它提供全局访问的方法。单例模式是一种对象创建型模式。

单例模式有三个要点:一是某个类只能有一个实例;二是它必须自行创建这个实例;三是它必须自行向整个系统提供这个实例。

3 饿汉式单例与懒汉式单例的讨论

 1.饿汉式单例类

 

class EagerSingleton { 
    private static final EagerSingleton instance = new EagerSingleton(); 
    private EagerSingleton() { } 
 
    public static EagerSingleton getInstance() {
        return instance; 
    }   
}

        当类被加载时,静态变量instance会被初始化,此时类的私有构造函数会被调用,单例类的唯一实例将被创建。如果使用饿汉式单例来实现负载均衡器LoadBalancer类的设计,则不会出现创建多个单例对象的情况,可确保单例对象的唯一性。

 

2.懒汉式单例类与线程锁定

   懒汉式单例在第一次调用getInstance()方法时实例化,在类加载时并不自行实例化,这种技术又称为延迟加载(Lazy Load)技术,即需要的时候再加载实例,为了避免多个线程同时调用getInstance()方法,我们可以使用关键字synchronized

 代码1:

class LazySingleton { 
    private static LazySingleton instance = null; 
 
    private LazySingleton() { } 
 
    synchronized public static LazySingleton getInstance() { 
        if (instance == null) {
            instance = new LazySingleton(); 
        }
        return instance; 
    }
}

  缺点:该懒汉式单例类在getInstance()方法前面增加了关键字synchronized进行线程锁,以处理多个线程同时访问的问题。但是,上述代码虽然解决了线程安全问题,但是每次调用getInstance()时都需要进行线程锁定判断,在多线程高并发访问环境中,将会导致系统性能大大降低。

改进代码2:

public static LazySingleton getInstance() { 
    if (instance == null) {
        synchronized (LazySingleton.class) {
            instance = new LazySingleton(); 
        }
    }
    return instance; 
}

  缺点:多线程问题。

改进代码3:

双重检查锁定(Double-Check Locking)

class LazySingleton { 
    private volatile static LazySingleton instance = null; 
 
    private LazySingleton() { } 
 
    public static LazySingleton getInstance() { 
        //第一重判断
        if (instance == null) {
            //锁定代码块
            synchronized (LazySingleton.class) {
                //第二重判断
                if (instance == null) {
                    instance = new LazySingleton(); //创建单例实例
                }
            }
        }
        return instance; 
    }
}

  

需要注意的是,如果使用双重检查锁定来实现懒汉式单例类,需要在静态成员变量instance之前增加修饰符volatile,被volatile修饰的成员变量可以确保多个线程都能够正确处理,且该代码只能在JDK 1.5及以上版本中才能正确执行。由于volatile关键字会屏蔽Java虚拟机所做的一些代码优化,可能会导致系统运行效率降低,因此即使使用双重检查锁定来实现单例模式也不是一种完美的实现方式。 

3.饿汉式单例类与懒汉式单例类比较 

  一句话:饿汉式单例类不能实现延迟加载,不管将来用不用始终占据内存;懒汉式单例类线程安全控制烦琐,而且性能受影响。

  饿汉式单例类在类被加载时就将自己实例化,它的优点在于无须考虑多线程访问问题,可以确保实例的唯一性;从调用速度和反应时间角度来讲,由于单例对象一开始就得以创建,因此要优于懒汉式单例。但是无论系统在运行时是否需要使用该单例对象,由于在类加载时该对象就需要创建,因此从资源利用效率角度来讲,饿汉式单例不及懒汉式单例,而且在系统加载时由于需要创建饿汉式单例对象,加载时间可能会比较长。

      懒汉式单例类在第一次使用时创建,无须一直占用系统资源,实现了延迟加载,但是必须处理好多个线程同时访问的问题,特别是当单例类作为资源控制器,在实例化时必然涉及资源初始化,而资源初始化很有可能耗费大量时间,这意味着出现多线程同时首次引用此类的机率变得较大,需要通过双重检查锁定等机制进行控制,这将导致系统性能受到一定影响。

4 一种更好的单例实现方法:IoDH

  IoDH(initialization on demand holder) 为一种延迟加载且线程安全的单例模式实现方式。这种方式的实现依赖于JVM对类加载过程中初始化阶段的执行。

      在IoDH中,我们在单例类中增加一个静态(static)内部类,在该内部类中创建单例对象,再将该单例对象通过getInstance()方法返回给外部使用,实现代码如下所示:

//Initialization on Demand Holder
class Singleton {
	private Singleton() {
	}
	
	private static class HolderClass {
            private final static Singleton instance = new Singleton();
	}
	
	public static Singleton getInstance() {
	    return HolderClass.instance;
	}
	
	public static void main(String args[]) {
	    Singleton s1, s2; 
            s1 = Singleton.getInstance();
	    s2 = Singleton.getInstance();
	    System.out.println(s1==s2);  //结果为true
	}
}

  由于静态单例对象没有作为Singleton的成员变量直接实例化,因此类加载时不会实例化Singleton,第一次调用getInstance()时将加载内部类HolderClass,在该内部类中定义了一个static类型的变量instance,此时会首先初始化这个成员变量,由Java虚拟机来保证其线程安全性,确保该成员变量只能初始化一次。由于getInstance()方法没有任何线程锁定,因此其性能不会造成任何影响。

      通过使用IoDH,我们既可以实现延迟加载,又可以保证线程安全,不影响系统性能,不失为一种最好的Java语言单例模式实现方式(其缺点是与编程语言本身的特性相关,很多面向对象语言不支持IoDH)。

存在的唯一一个问题:只能用于能保证初始化不会失败的情况,否则会导致Holder类没有成功加载,使用时报java.lang.NoClassDefFoundError: Could not initialize class SingleTon$Holder

分析下这个单例类的初始化过程:
  - 当SingleTon类被JVM加载时,由于这个类没有其他静态属性,其初始化过程会顺利完成。但是内部静态类Holder直到调用getInstance()时才会被初始化。
  - 当Holder第一次被执行时,JVM会加载并初始化该类。由于Holder含有静态方法INSTANCE,因此会一并初始化INSTANCE。JLS保证了类的初始化阶段是连续的。这样,所有后序的并发调用getInstance()都会返回一个正确初始化的INSTANCE而不会有额外同步开销。
  - 但是,任何初始化失败都会导致单例类不可用。也就是说,IoDH这种实现方式只能用于能保证初始化不会失败的情况。
  参考:https://blog.csdn.net/f59130/article/details/80912055

5 多例模式 - 池化的单例

基于单例模式我们可以进行扩展,使用与单例控制相似的方法来获得指定个数的对象实例,既节省系统资源,又解决了单例单例对象共享过多有损性能的问题。

多例模式的定义:

作为对象的创建模式,多例模式中的多例类可以有多个实例,而且多例类必须自己创建、管理自己的实例,并向外界提供自己的实例。

多例模式的特点:

所谓的多例模式(Multiton Pattern),实际上就是单例模式的自然推广。作为对象的创建模式,多例模式或多例类有如下的特点:

(1)多例类可有多个实例

(2)多例类必须自己创建、管理自己的实例,并向外界提供自己的实例。

(3)根据是否有实例上限分为:有上限多例类和无上限多例类。

 多例模式的具体实现:

package com.test.zhj;

import java.util.ArrayList;
import java.util.Random;

public class Emperor {

    private static int maxNumOfEmperor = 2; // 最多只能有连个皇帝
    private static ArrayList emperorInfoList = new ArrayList(maxNumOfEmperor); // 皇帝叫什么名字
    private static ArrayList emperorList = new ArrayList(maxNumOfEmperor); // 装皇帝的列表;
    private static int countNumOfEmperor = 0; // 正在被人尊称的是那个皇帝
    // 先把2个皇帝产生出来
    static {
        // 把所有的皇帝都产生出来
        for (int i = 0; i < maxNumOfEmperor; i++) {
            emperorList.add(new Emperor("皇" + (i + 1) + "帝"));
        }
    }

    // 就这么多皇帝了,不允许再推举一个皇帝(new 一个皇帝)
    private Emperor() {
        // 世俗和道德约束你,目的就是不让你产生第二个皇帝
    }

    private Emperor(String info) {
        emperorInfoList.add(info);
    }

    public static Emperor getInstance() {
        Random random = new Random();
        countNumOfEmperor = random.nextInt(maxNumOfEmperor); // 随机拉出一个皇帝,只要是个精神领袖就成
        return (Emperor) emperorList.get(countNumOfEmperor);
    }

    // 皇帝叫什么名字呀
    public static void emperorInfo() {
        System.out.println(emperorInfoList.get(countNumOfEmperor));
    }

}

  

6 单例模式总结

 

1.主要优点

       单例模式的主要优点如下:

       (1) 单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例,所以它可以严格控制客户怎样以及何时访问它。

       (2) 由于在系统内存中只存在一个对象,因此可以节约系统资源,对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。

       (3) 允许可变数目的实例。基于单例模式我们可以进行扩展,使用与单例控制相似的方法来获得指定个数的对象实例,既节省系统资源,又解决了单例单例对象共享过多有损性能的问题。

 

2.主要缺点

       单例模式的主要缺点如下:

       (1) 由于单例模式中没有抽象层,因此单例类的扩展有很大的困难。

       (2) 单例类的职责过重,在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色,提供了工厂方法,同时又充当了产品角色,包含一些业务方法,将产品的创建和产品的本身的功能融合到一起。

       (3) 现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术,因此,如果实例化的共享对象长时间不被利用,系统会认为它是垃圾,会自动销毁并回收资源,下次利用时又将重新实例化,这将导致共享的单例对象状态的丢失。

 

3.适用场景

       在以下情况下可以考虑使用单例模式:

       (1) 系统只需要一个实例对象,如系统要求提供一个唯一的序列号生成器或资源管理器,或者需要考虑资源消耗太大而只允许创建一个对象。

       (2) 客户调用类的单个实例只允许使用一个公共访问点,除了该公共访问点,不能通过其他途径访问该实例。

 

7 参考

确保对象的唯一性——单例模式 (一):单例模式的动机,单例模式概述

确保对象的唯一性——单例模式 (二):负载均衡器的设计与实现

确保对象的唯一性——单例模式 (三):饿汉式单例与懒汉式单例的讨论

确保对象的唯一性——单例模式 (四):一种更好的单例实现方法(静态内部类)

确保对象的唯一性——单例模式 (五):单例模式总结

 https://blog.csdn.net/f59130/article/details/80912055

 

猜你喜欢

转载自www.cnblogs.com/aoyihuashao/p/10080413.html
0条评论
添加一条新回复