首页    技术博客    PHP教程    数据库技术    前端开发   HTML5    Nginx    php论坛
新用户注册 | 会员登录
加入会员，解锁专属内容
取消
热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

单例模式懒汉、饿汉和登记

作者：朱劭文_850 | 来源：互联网 | 2023-10-14 14:40
转载自JAVA设计模式之单例模式本文继续介绍23种设计模式系列之单例模式。概念：java中单例模式是一种常见的设计模式，单例模式的写法有好几种&#

转载自  JAVA设计模式之单例模式

本文继续介绍23种设计模式系列之单例模式。

概念&＃xff1a;
　　java中单例模式是一种常见的设计模式&＃xff0c;单例模式的写法有好几种&＃xff0c;这里主要介绍三种&＃xff1a;懒汉式单例、饿汉式单例、登记式单例。
　　单例模式有以下特点&＃xff1a;
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。
　　单例模式确保某个类只有一个实例&＃xff0c;而且自行实例化并向整个系统提供这个实例。在计算机系统中&＃xff0c;线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机&＃xff0c;但只能有一个Printer Spooler&＃xff0c;以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口&＃xff0c;系统应当集中管理这些通信端口&＃xff0c;以避免一个通信端口同时被两个请求同时调用。总之&＃xff0c;选择单例模式就是为了避免不一致状态&＃xff0c;避免政出多头。


一、懒汉式单例


[java] view plaincopy
  1. //懒汉式单例类.在第一次调用的时候实例化自己   
  2. public class Singleton {  
  3.     private Singleton() {}  
  4.     private static Singleton single&＃61;null;  
  5.     //静态工厂方法   
  6.     public static Singleton getInstance() {  
  7.          if (single &＃61;&＃61; null) {    
  8.              single &＃61; new Singleton();  
  9.          }    
  10.         return single;  
  11.     }  
  12. }  





Singleton通过将构造方法限定为private避免了类在外部被实例化&＃xff0c;在同一个虚拟机范围内&＃xff0c;Singleton的唯一实例只能通过getInstance()方法访问。

&＃xff08;事实上&＃xff0c;通过Java反射机制是能够实例化构造方法为private的类的&＃xff0c;那基本上会使所有的Java单例实现失效。此问题在此处不做讨论&＃xff0c;姑且掩耳盗铃地认为反射机制不存在。&＃xff09;

但是以上懒汉式单例的实现没有考虑线程安全问题&＃xff0c;它是线程不安全的&＃xff0c;并发环境下很可能出现多个Singleton实例&＃xff0c;要实现线程安全&＃xff0c;有以下三种方式&＃xff0c;都是对getInstance这个方法改造&＃xff0c;保证了懒汉式单例的线程安全&＃xff0c;如果你第一次接触单例模式&＃xff0c;对线程安全不是很了解&＃xff0c;可以先跳过下面这三小条&＃xff0c;去看饿汉式单例&＃xff0c;等看完后面再回头考虑线程安全的问题&＃xff1a;


1、在getInstance方法上加同步


[java] view plaincopy
  1. public static synchronized Singleton getInstance() {  
  2.          if (single &＃61;&＃61; null) {    
  3.              single &＃61; new Singleton();  
  4.          }    
  5.         return single;  
  6. }  



2、双重检查锁定


[java] view plaincopy
  1. public static Singleton getInstance() {  
  2.         if (singleton &＃61;&＃61; null) {    
  3.             synchronized (Singleton.class) {    
  4.                if (singleton &＃61;&＃61; null) {    
  5.                   singleton &＃61; new Singleton();   
  6.                }    
  7.             }    
  8.         }    
  9.         return singleton;   
  10.     }  

3、静态内部类


[java] view plaincopy
  1. public class Singleton {    
  2.     private static class LazyHolder {    
  3.        private static final Singleton INSTANCE &＃61; new Singleton();    
  4.     }    
  5.     private Singleton (){}    
  6.     public static final Singleton getInstance() {    
  7.        return LazyHolder.INSTANCE;    
  8.     }    
  9. }    


这种比上面1、2都好一些&＃xff0c;既实现了线程安全&＃xff0c;又避免了同步带来的性能影响。




二、饿汉式单例


[java] view plaincopy
  1. //饿汉式单例类.在类初始化时&＃xff0c;已经自行实例化   
  2. public class Singleton1 {  
  3.     private Singleton1() {}  
  4.     private static final Singleton1 single &＃61; new Singleton1();  
  5.     //静态工厂方法   
  6.     public static Singleton1 getInstance() {  
  7.         return single;  
  8.     }  
  9. }  


饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用&＃xff0c;以后不再改变&＃xff0c;所以天生是线程安全的。





三、登记式单例(可忽略)


[java] view plaincopy
  1. //类似Spring里面的方法&＃xff0c;将类名注册&＃xff0c;下次从里面直接获取。  
  2. public class Singleton3 {  
  3.     private static Map map &＃61; new HashMap();  
  4.     static{  
  5.         Singleton3 single &＃61; new Singleton3();  
  6.         map.put(single.getClass().getName(), single);  
  7.     }  
  8.     //保护的默认构造子  
  9.     protected Singleton3(){}  
  10.     //静态工厂方法,返还此类惟一的实例  
  11.     public static Singleton3 getInstance(String name) {  
  12.         if(name &＃61;&＃61; null) {  
  13.             name &＃61; Singleton3.class.getName();  
  14.             System.out.println("name &＃61;&＃61; null"&＃43;"--->name&＃61;"&＃43;name);  
  15.         }  
  16.         if(map.get(name) &＃61;&＃61; null) {  
  17.             try {  
  18.                 map.put(name, (Singleton3) Class.forName(name).newInstance());  
  19.             } catch (InstantiationException e) {  
  20.                 e.printStackTrace();  
  21.             } catch (IllegalAccessException e) {  
  22.                 e.printStackTrace();  
  23.             } catch (ClassNotFoundException e) {  
  24.                 e.printStackTrace();  
  25.             }  
  26.         }  
  27.         return map.get(name);  
  28.     }  
  29.     //一个示意性的商业方法  
  30.     public String about() {      
  31.         return "Hello, I am RegSingleton.";      
  32.     }      
  33.     public static void main(String[] args) {  
  34.         Singleton3 single3 &＃61; Singleton3.getInstance(null);  
  35.         System.out.println(single3.about());  
  36.     }  
  37. }  

 登记式单例实际上维护了一组单例类的实例&＃xff0c;将这些实例存放在一个Map&＃xff08;登记薄&＃xff09;中&＃xff0c;对于已经登记过的实例&＃xff0c;则从Map直接返回&＃xff0c;对于没有登记的&＃xff0c;则先登记&＃xff0c;然后返回。 

这里我对登记式单例标记了可忽略&＃xff0c;我的理解来说&＃xff0c;首先它用的比较少&＃xff0c;另外其实内部实现还是用的饿汉式单例&＃xff0c;因为其中的static方法块&＃xff0c;它的单例在类被装载的时候就被实例化了。


饿汉式和懒汉式区别

从名字上来说&＃xff0c;饿汉和懒汉&＃xff0c;

饿汉就是类一旦加载&＃xff0c;就把单例初始化完成&＃xff0c;保证getInstance的时候&＃xff0c;单例是已经存在的了&＃xff0c;

而懒汉比较懒&＃xff0c;只有当调用getInstance的时候&＃xff0c;才回去初始化这个单例。

另外从以下两点再区分以下这两种方式&＃xff1a;


1、线程安全&＃xff1a;

饿汉式天生就是线程安全的&＃xff0c;可以直接用于多线程而不会出现问题&＃xff0c;

懒汉式本身是非线程安全的&＃xff0c;为了实现线程安全有几种写法&＃xff0c;分别是上面的1、2、3&＃xff0c;这三种实现在资源加载和性能方面有些区别。



2、资源加载和性能&＃xff1a;

饿汉式在类创建的同时就实例化一个静态对象出来&＃xff0c;不管之后会不会使用这个单例&＃xff0c;都会占据一定的内存&＃xff0c;但是相应的&＃xff0c;在第一次调用时速度也会更快&＃xff0c;因为其资源已经初始化完成&＃xff0c;

而懒汉式顾名思义&＃xff0c;会延迟加载&＃xff0c;在第一次使用该单例的时候才会实例化对象出来&＃xff0c;第一次调用时要做初始化&＃xff0c;如果要做的工作比较多&＃xff0c;性能上会有些延迟&＃xff0c;之后就和饿汉式一样了。

至于1、2、3这三种实现又有些区别&＃xff0c;

第1种&＃xff0c;在方法调用上加了同步&＃xff0c;虽然线程安全了&＃xff0c;但是每次都要同步&＃xff0c;会影响性能&＃xff0c;毕竟99%的情况下是不需要同步的&＃xff0c;

第2种&＃xff0c;在getInstance中做了两次null检查&＃xff0c;确保了只有第一次调用单例的时候才会做同步&＃xff0c;这样也是线程安全的&＃xff0c;同时避免了每次都同步的性能损耗

第3种&＃xff0c;利用了classloader的机制来保证初始化instance时只有一个线程&＃xff0c;所以也是线程安全的&＃xff0c;同时没有性能损耗&＃xff0c;所以一般我倾向于使用这一种。


什么是线程安全&＃xff1f;

如果你的代码所在的进程中有多个线程在同时运行&＃xff0c;而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的&＃xff0c;而且其他的变量的值也和预期的是一样的&＃xff0c;就是线程安全的。

或者说&＃xff1a;一个类或者程序所提供的接口对于线程来说是原子操作&＃xff0c;或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题&＃xff0c;那就是线程安全的。


应用

以下是一个单例类使用的例子&＃xff0c;以懒汉式为例&＃xff0c;这里为了保证线程安全&＃xff0c;使用了双重检查锁定的方式&＃xff1a;


[java] view plaincopy
  1. public class TestSingleton {  
  2.     String name &＃61; null;  
  3.   
  4.         private TestSingleton() {  
  5.     }  
  6.   
  7.     private static volatile TestSingleton instance &＃61; null;  
  8.   
  9.     public static TestSingleton getInstance() {  
  10.            if (instance &＃61;&＃61; null) {    
  11.              synchronized (TestSingleton.class) {    
  12.                 if (instance &＃61;&＃61; null) {    
  13.                    instance &＃61; new TestSingleton();   
  14.                 }    
  15.              }    
  16.            }   
  17.            return instance;  
  18.     }  
  19.   
  20.     public String getName() {  
  21.         return name;  
  22.     }  
  23.   
  24.     public void setName(String name) {  
  25.         this.name &＃61; name;  
  26.     }  
  27.   
  28.     public void printInfo() {  
  29.         System.out.println("the name is " &＃43; name);  
  30.     }  
  31.   
  32. }  

可以看到里面加了volatile关键字来声明单例对象&＃xff0c;既然synchronized已经起到了多线程下原子性、有序性、可见性的作用&＃xff0c;为什么还要加volatile呢&＃xff0c;原因已经在下面评论中提到&＃xff0c;

还有疑问可参考http://www.iteye.com/topic/652440
和http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html




[java] view plaincopy
  1. public class TMain {  
  2.     public static void main(String[] args){  
  3.         TestStream ts1 &＃61; TestSingleton.getInstance();  
  4.         ts1.setName("jason");  
  5.         TestStream ts2 &＃61; TestSingleton.getInstance();  
  6.         ts2.setName("0539");  
  7.           
  8.         ts1.printInfo();  
  9.         ts2.printInfo();  
  10.           
  11.         if(ts1 &＃61;&＃61; ts2){  
  12.             System.out.println("创建的是同一个实例");  
  13.         }else{  
  14.             System.out.println("创建的不是同一个实例");  
  15.         }  
  16.     }  
  17. }  

 运行结果&＃xff1a;


结论&＃xff1a;由结果可以得知单例模式为一个面向对象的应用程序提供了对象惟一的访问点&＃xff0c;不管它实现何种功能&＃xff0c;整个应用程序都会同享一个实例对象。

对于单例模式的几种实现方式&＃xff0c;知道饿汉式和懒汉式的区别&＃xff0c;线程安全&＃xff0c;资源加载的时机&＃xff0c;还有懒汉式为了实现线程安全的3种方式的细微差别。




推荐阅读
  • 安全

    图解redis的持久化存储机制RDB和AOF的原理和优缺点

    图解redis的持久化存储机制RDB和AOF的原理和优缺点
    本文通过图解的方式介绍了redis的持久化存储机制RDB和AOF的原理和优缺点。RDB是将redis内存中的数据保存为快照文件，恢复速度较快但不支持拉链式快照。AOF是将操作日志保存到磁盘，实时存储数据但恢复速度较慢。文章详细分析了两种机制的优缺点，帮助读者更好地理解redis的持久化存储策略。 ... [详细]
  • instance

    Java高并发程序设计学习-线程安全的概念与synchronized

    本文介绍了Java高并发程序设计中线程安全的概念与synchronized关键字的使用。通过一个计数器的例子，演示了多线程同时对变量进行累加操作时可能出现的问题。最终值会小于预期的原因是因为两个线程同时对变量进行写入时，其中一个线程的结果会覆盖另一个线程的结果。为了解决这个问题，可以使用synchronized关键字来保证线程安全。 ... [详细]
  • instance

    org.apache.catalina.LifecycleEvent类的使用及代码示例

    标题： ... [详细]
  • const

    clone的fork与pthread_create创建线程有何不同

    本文讨论了clone的fork与pthread_create创建线程的不同之处。进程是一个指令执行流及其执行环境，其执行环境是一个系统资源的集合。在调用系统调用fork创建一个进程时，子进程只是完全复制父进程的资源，这样得到的子进程独立于父进程，具有良好的并发性。但是二者之间的通讯需要通过专门的通讯机制，另外通过fork创建子进程系统开销很大。因此，在某些情况下，使用clone或pthread_create创建线程可能更加高效。 ... [详细]
  • const

    深入浅出Linux设备驱动编程的重要性与方法

    本文介绍了深入浅出Linux设备驱动编程的重要性，以及两种加载和删除Linux内核模块的方法。通过一个内核模块的例子，展示了模块的编译和加载过程，并讨论了模块对内核大小的控制。深入理解Linux设备驱动编程对于开发者来说非常重要。 ... [详细]
  • const

    Oracle 11g物理Active Data Guard实时查询（Realtime query）特性

    在Oracle11g以前版本中的的DataGuard物理备用数据库，可以以只读的方式打开数据库，但此时MediaRecovery利用日志进行数据同步的过 ... [详细]
  • go

    SpringBoot整合SpringSecurity+JWT实现单点登录

    SpringBoot整合SpringSecurity+JWT实现单点登录
    SpringBoot整合SpringSecurity+JWT实现单点登录,Go语言社区,Golang程序员人脉社 ... [详细]
  • uri

    全面介绍Windows内存管理机制及C++内存分配实例（四）：内存映射文件

    全面介绍Windows内存管理机制及C++内存分配实例（四）：内存映射文件
    本文旨在全面介绍Windows内存管理机制及C++内存分配实例中的内存映射文件。通过对内存映射文件的使用场合和与虚拟内存的区别进行解析，帮助读者更好地理解操作系统的内存管理机制。同时，本文还提供了相关章节的链接，方便读者深入学习Windows内存管理及C++内存分配实例的其他内容。 ... [详细]
  • java

    Java中vector的使用详解

    本文详细介绍了Java中vector的使用方法和相关知识，包括vector类的功能、构造方法和使用注意事项。通过使用vector类，可以方便地实现动态数组的功能，并且可以随意插入不同类型的对象，进行查找、插入和删除操作。这篇文章对于需要频繁进行查找、插入和删除操作的情况下，使用vector类是一个很好的选择。 ... [详细]
  • utf-8

    南邮ctf-web的writeup

    本文介绍了南邮ctf-web的writeup，包括签到题和md5 collision。在CTF比赛和渗透测试中，可以通过查看源代码、代码注释、页面隐藏元素、超链接和HTTP响应头部来寻找flag或提示信息。利用PHP弱类型，可以发现md5('QNKCDZO')='0e830400451993494058024219903391'和md5('240610708')='0e462097431906509019562988736854'。 ... [详细]
  • express

    Windows操作系统的版本介绍及特点

    本文介绍了Windows操作系统的版本及其特点，包括Windows 7系统的6个版本：Starter、Home Basic、Home Premium、Professional、Enterprise、Ultimate。Windows操作系统是微软公司研发的一套操作系统，具有人机操作性优异、支持的应用软件较多、对硬件支持良好等优点。Windows 7 Starter是功能最少的版本，缺乏Aero特效功能，没有64位支持，最初设计不能同时运行三个以上应用程序。 ... [详细]
  • express

    OO第一单元自白：简单多项式导函数的设计与bug分析

    OO第一单元自白：简单多项式导函数的设计与bug分析
    本文介绍了作者在学习OO的第一次作业中所遇到的问题及其解决方案。作者通过建立Multinomial和Monomial两个类来实现多项式和单项式，并通过append方法将单项式组合为多项式，并在此过程中合并同类项。作者还介绍了单项式和多项式的求导方法，并解释了如何利用正则表达式提取各个单项式并进行求导。同时，作者还对自己在输入合法性判断上的不足进行了bug分析，指出了自己在处理指数情况时出现的问题，并总结了被hack的原因。 ... [详细]
  • install

    CentOS安装Python2.7.2的步骤和注意事项

    本文介绍了在CentOS上安装Python2.7.2的详细步骤，包括下载、解压、编译和安装等操作。同时提供了一些注意事项，以及测试安装是否成功的方法。 ... [详细]
  • instance

    InnoDB存储引擎——内存

    上图是InnoDB存储引擎的结构。1、缓冲池InnoDB存储引擎是基于磁盘存储的，并将其中的记录按照页的方式进行管理。因此可以看作是基于磁盘的数据库系统。在数据库系统中，由于CPU速度 ... [详细]
  • hash

    HashMap的相关问题及其底层数据结构和操作流程

    HashMap的相关问题及其底层数据结构和操作流程
    本文介绍了关于HashMap的相关问题，包括其底层数据结构、JDK1.7和JDK1.8的差异、红黑树的使用、扩容和树化的条件、退化为链表的情况、索引的计算方法、hashcode和hash()方法的作用、数组容量的选择、Put方法的流程以及并发问题下的操作。文章还提到了扩容死链和数据错乱的问题，并探讨了key的设计要求。对于对Java面试中的HashMap问题感兴趣的读者，本文将为您提供一些有用的技术和经验。 ... [详细]
author-avatar
朱劭文_850
这个家伙很懒，什么也没留下！
Tags | 热门标签
RankList | 热门文章
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有