设计模式学习笔记(三):单例模式

1 概述

1.1 引言

很多时候为了节约系统资源,需要确保系统中某个类只有一个唯一的实例,当这个唯一实例创建了之后,无法再创建一个同类型的其他对象,所有的操作只能基于这一个唯一实例。这是单例模式的动机所在。

比如Windows的任务管理器,可以按Ctrl+Shift+Esc启动,而且启动一个,不能启动多个。

1.2 定义

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

单例模式是一种对象创建型模式。

1.3 结构图

在这里插入图片描述

1.4 角色

单例模式只有一个角色:

  • Singleton(单例角色):在单例类的内部只生成一个实例,同时它提供一个类似名叫getInstance的静态方法获取实例,同时为了防止外部生成新的实例化对象,构造方法可见性为private,在单例类内部定义了一个Singleton的静态对象,作为供外部访问的唯一实例

2 典型实现

2.1 步骤

  • 构造函数私有化:也就是禁止外部直接使用new等方式创建对象
  • 定义静态成员:定义一个私有静态成员保存实例
  • 增加公有静态方法:增加一个类似getInstance()的公有静态方法来获取实例

2.2 单例角色

单例角色通常实现如下:

class Singleton
{
	//饿汉式实现
    private static Singleton instance = new Singleton();
    private Singleton(){}
    public static Singleton getInstance()
    {
        return instance;
    }
}

2.3 客户端

客户端直接通过该类获取实例即可:

Singleton singleton = Singleton.getInstance();

3 实例

某个软件需要使用一个全局唯一的负载均衡器,使用单例模式对其进行设计。

代码如下:

public class LoadBalancer
{
    private static LoadBalancer instance = null;

    private LoadBalancer(){}

    public static LoadBalancer getInstance()
    {
        return instance == null ? instance = new LoadBalancer() : instance;
    }

    public static void main(String[] args) {
        LoadBalancer balancer1 = LoadBalancer.getInstance();
        LoadBalancer balancer2 = LoadBalancer.getInstance();
        System.out.println(balancer1 == balancer2);
    }
}

这是最简单的单例类的设计,获取实例时仅仅判断是否为null,没有考虑到线程问题。也就是说,多个线程同时获取实例时,还是有可能会产生多个实例,一般来说,常见的解决方式如下:

  • 饿汉式单例
  • 懒汉式单例
  • IoDH

4 饿汉式单例

饿汉式单例就是在普通的单例类基础上,在定义静态变量时就直接实例化,因此在类加载的时候就已经创建了单例对象,而且在获取实例时不需要进行判空操作直接返回实例即可:

public class LoadBalancer
{
    private static LoadBalancer instance = new LoadBalancer();

    private LoadBalancer(){}

    public static LoadBalancer getInstance()
    {
        return instance;
    }
}

当类被加载时,静态变量instance被初始化,类的私有构造方法将被调用,单例类的唯一实例将被创建。

5 懒汉式单例

懒汉式单例在类加载时不进行初始化,在需要的时候再初始化,加载实例,同时为了避免多个线程同时调用getInstance(),可以加上synchronized

public class LoadBalancer
{
    private static LoadBalancer instance = null;

    private LoadBalancer(){}

    synchronized public static LoadBalancer getInstance()
    {
        return instance == null ? instance = new LoadBalancer() : instance;
    }
}

这种技术又叫延迟加载技术,尽管解决了多个线程同时访问的问题,但是每次调用时都需要进行线程锁定判断,这样会降低效率。

事实上,单例的核心在于instance = new LoadBalancer(),因此只需要锁定这行代码,优化如下:

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

但是实际情况中还是有可能出现多个实例,因为如果A和B两个线程同时调用getInstance(),都通过了if(instance == null)的判断,假设线程A先获得锁,创建实例后,A释放锁,接着B获取锁,再次创建了一个实例,这样还是导致产生多个单例对象。

因此,通常采用一种叫“双重检查锁定”的方式来确保不会产生多个实例,一个线程获取锁后再进行一次判空操作:

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

需要注意的是要使用volatile修饰变量,volatile可以保证可见性以及有序性。

6 饿汉式与懒汉式的比较

  • 饿汉式在类加载时就已经初始化,优点在于无需考虑多线程访问问题,可以确保实例的唯一性
  • 从调用速度方面来说饿汉式会优于懒汉式,因为在类加载时就已经被创建
  • 从资源利用效率来说饿汉式会劣于懒汉式,因为无论是否需要使用都会加载单例对象,而且由于加载时需要创建实例会导致类加载时间变长
  • 懒汉式实现了延迟加载,无须一直占用系统资源
  • 懒汉式需要处理多线程并发访问问题,需要双重检查锁定,且通常来说初始化过程需要较长时间,会增大多个线程同时首次调用的几率,这会导致系统性能受一定影响

7 IoDH

为了克服饿汉式不能延迟加载以及懒汉式的线程安全控制繁琐问题,可以使用一种叫Initialization on Demand Holder(IoDH)的技术。实现IoDH时,需在单例类增加一个静态内部类,在该内部类中创建单例对象,再将该单例对象通过getInstance()方法返回给外部使用,代码如下:

public class LoadBalancer
{
	private LoadBalancer(){}
	private static class HolderClass
	{
		private static final LoadBalancer instance = new LoadBalancer();
	}
	
	public static LoadBalancer getInstance()
	{
		return HolderClass.instance;
	}
}

由于单例对象没有作为LoadBalancer的成员变量直接实例化,因此类加载时不会实例化instance。首次调用getInstance()时,会初始化instance,由JVM保证线程安全性,确保只能被初始化一次。另外相比起懒汉式单例,getInstance()没有线程锁定,因此性能不会有任何影响。

通过IoDH既可以实现延迟加载,又可以保证线程安全,不影响系统性能,但是缺点是与编程语言本身的特性相关,很多面向对象语言不支持IoDH。另外,还可能引发NoClassDefFoundError(当初始化失败时),例子可以戳这里

8 枚举实现单例(推荐)

其中,无论是饿汉式,还是懒汉式,还是IoDH,都有或多或少的问题,并且还可以通过反射以及序列化/反序列化方式去“强制”生成多个单例,有没有更优雅的解决方案呢?

有!答案就是枚举。

代码如下:

public class Test
{
    public static void main(String[] args) {
        LoadBalancer balancer1 = LoadBalancer.INSTANCE;
        LoadBalancer balancer2 = LoadBalancer.INSTANCE;
        System.out.println(balancer1 == balancer2);
    }
}

enum LoadBalancer{
    INSTANCE;
}

使用枚举实现单例优点如下:

  • 代码简洁不易出错
  • 无须像饿汉式一样直接在类加载时初始化
  • 也无须像懒汉式一样需要双重检查锁定
  • 也无须像IoDH一样添加一个静态内部类增加系统中类的数量
  • 由JVM保证线程安全
  • 不会因为序列化生成新实例
  • 也不会因为反射生产新实例

9 主要优点

  • 唯一实例:单例模式提供了对唯一实例的受控访问,可以严格控制客户怎样以及何时访问它
  • 节约资源:由于在系统内存中只存在一个对象,因此可以节约系统资源,对于一些需要频繁创建和销毁的对象,单例模式可以提高系统性能

10 主要缺点

  • 扩展困难:没有抽象层,扩展困难
  • 职责过重:单例类职责过重,一定程度上违反了SRP,因为既提供了业务方法,也提供了创建对象方法,将对象创建以及对象本身的功能耦合在一起
  • GC导致重新实例化:很多语言提供了GC机制,实例化的对象长时间不使用将被回收,下次使用需要重新实例化,这会导致共享的单例对象状态丢失

11 适用场景

  • 系统需要一个实例对象
  • 客户调用类的单个实例只允许使用一个公共访问点

12 总结

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值