我是靠谱客的博主 粗犷画笔,这篇文章主要介绍理解单例模式及其IoDH实现单例模式,现在分享给大家,希望可以做个参考。

单例模式

1.什么是单例模式?

单例模式的目的是保证一个类里只有一个实例,并提供一个访问它的全局访问点。

2.单例模式的设计方法:

2.1懒汉式:

  • 一个私有的构造函数:确保只能由类自身创建实例,不能被外部构造或被子类继承。
  • 静态的未实例化的私有成员变量:即该类的实例,确保一个类只能有一个实例。
  • 静态的公用工厂方法:全局访问点提供给其他类调用获取实例。

当要使用这个类时,通过该类的工厂方法生成该类的实例,工厂方法会判断实例是否已经存在,存在则返回该实例,否则创建一个实例返回。

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
public class SingleTon2(){ private SingleTon2(){ } private static SingleTon2 singleton2 = null; public static getInstance(){ if(singleton2 == null){ singleton2 = new SingleTon2(); } return singleton2 ; } }

2.2饿汉式:

  • 实例化的静态私有成员变量:确保实例不能直接被外界获取。
  • 私有的空参构造器:防止系统默认生成公有的空参构造器。
  • 静态的共有方法:全局访问点提供给其他类调用获取实例。
复制代码
1
2
3
4
5
6
7
8
9
public class SingleTon1(){ private SingleTon1(){ } private static SingleTon1 singleton = new SingleTon1(); public static getInstance(){ return singleton ; } }

3.两种设计方法对比

3.1普通的懒汉式单例模式

优点

  • 使用对象延迟加载的思想:效率高

    ?延迟加载:程序启动时并不立即加载资源或者数据,等到马上要使用时再加载。

缺点

  • 线程不安全的。

    普通的懒汉式单例模式不具有原子性,当程序中引用多线程时,系统中可能会出现多个单例类的实例对象。这违背了单例模式的初衷。

  • 操作比饿汉式复杂

优化

1. 在工厂方法前加上synchronized关键字确保原子性
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
//除第一次使用,getInstance()需要同步,后面getInstance()不需要同步;每次同步,效率很低。 public class SingleTon3(){ private SingleTon3(){ } private static SingleTon3 singleton3 = null; public synchronized static getInstance(){ if(singleton3 == null){ singleton3 = new SingleTon3(); } return singleton3 ; } }

优点

  • 解决单例模式线程安全性问题

缺点

  • 每次获取实例时线程都需要同步,使得效率变低
  • 加锁机制使得获取对象速度较慢
2. 双重校验锁模式
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//安全且在多线程情况下能保持高性能。 //实例变量需要加volatile 关键字保证易变可见性 public class SingleTon4{ private SingleTon4(){ } private volatile static SingleTon4 singleton4 = null; public static SingleTon4 getSingleton(){ if(singleton4 == null){ synchronized (SingleTon4.class){ if(singleton4 == null){ singleton4 = new SingleTon3(); } } } return singleton4 ; } }

优点

  • 在保证多线程安全情况下能保持较高性能

缺点:

  • 获取实例时需要通过锁机制,导致获取对象速度较慢

3.2饿汉式单例

优点:

  • 线程安全
  • 获取对象实例反应速度快

缺点:

  • 系统加载时间较长

4.扩展

IoDH(Initialization Demand Holder)实现单例模式

复制代码
1
2
3
4
5
6
7
8
9
10
11
class Singleton { private Singleton() { } private static class HolderClass { private final static Singleton instance = new Singleton(); } public static Singleton getInstance() { return HolderClass.instance; } }

优点:

  • 实现延迟加载
  • 保证线程安全:相当于间接使用饿汉模式,静态内部类一旦被加载就直接创建一个单例实例。
  • 不影响系统性能:既不会在程序启动时加载类,也不会在获取对象时进行加锁控制。

缺点

  • 与编程语言本身的特性相关,很多面向对象语言不支持IoDH

提问

了解到IoDH这里的时候有一些小小的迷惑,静态内部类实现延迟加载?静态内部类不是程序启动时就加载的吗?带着这个问题自己写了一个小小的测试代码:

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class testStaticClass { static class a{ static { System.out.println("静态内部类被加载"); } } static { System.out.println("静态代码块被加载"); } public static void main(String[] args) { } }

在这里插入图片描述

可以看到在运行该程序时静态代码块确实是在程序启动时就被加载,但静态内部类中的静态代码块并没有被加载。为了确认自己的验证,通过查阅书籍了解到:

内部类和静态内部类都是延时加载的,也就是说只有在明确用到内部类时才加载。

最后

以上就是粗犷画笔最近收集整理的关于理解单例模式及其IoDH实现单例模式的全部内容,更多相关理解单例模式及其IoDH实现单例模式内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供,作为学习参考使用,或来自网络收集整理,版权属于原作者所有。
点赞(75)

评论列表共有 0 条评论

立即
投稿
返回
顶部