首页    技术博客    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种方式的细微差别。




推荐阅读
  • get

    Spring特性实现接口多类的动态调用详解

    Spring特性实现接口多类的动态调用详解
    本文详细介绍了如何使用Spring特性实现接口多类的动态调用。通过对Spring IoC容器的基础类BeanFactory和ApplicationContext的介绍，以及getBeansOfType方法的应用，解决了在实际工作中遇到的接口及多个实现类的问题。同时，文章还提到了SPI使用的不便之处，并介绍了借助ApplicationContext实现需求的方法。阅读本文，你将了解到Spring特性的实现原理和实际应用方式。 ... [详细]
  • instance

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

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

    在重复造轮子的情况下用ProxyServlet反向代理来减少工作量

    在重复造轮子的情况下用ProxyServlet反向代理来减少工作量
    像不少公司内部不同团队都会自己研发自己工具产品，当各个产品逐渐成熟，到达了一定的发展瓶颈，同时每个产品都有着自己的入口，用户 ... [详细]
  • get

    springmvc学习笔记(十)：控制器业务方法中通过注解实现封装Javabean接收表单提交的数据

    springmvc学习笔记(十)：控制器业务方法中通过注解实现封装Javabean接收表单提交的数据
    本文介绍了在springmvc学习笔记系列的第十篇中，控制器的业务方法中如何通过注解实现封装Javabean来接收表单提交的数据。同时还讨论了当有多个注册表单且字段完全相同时，如何将其交给同一个控制器处理。 ... [详细]
  • get

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

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

    Python爬虫技术基础篇面向对象高级编程（中）的多重继承

    本文介绍了Python爬虫技术基础篇面向对象高级编程（中）中的多重继承概念。通过继承，子类可以扩展父类的功能。文章以动物类层次的设计为例，讨论了按照不同分类方式设计类层次的复杂性和多重继承的优势。最后给出了哺乳动物和鸟类的设计示例，以及能跑、能飞、宠物类和非宠物类的增加对类数量的影响。 ... [详细]
  • object

    javaweb多图片打包下载，弹出提示框问题_html/css_WEBITnose

    在springmvc框架中，前台ajax调用方法，对图片批量下载，如何弹出提示保存位置选框？Controller方法 ... [详细]
  • get

    基于Socket的多个客户端之间的聊天功能实现方法

    基于Socket的多个客户端之间的聊天功能实现方法
    本文介绍了基于Socket的多个客户端之间实现聊天功能的方法，包括服务器端的实现和客户端的实现。服务器端通过每个用户的输出流向特定用户发送消息，而客户端通过输入流接收消息。同时，还介绍了相关的实体类和Socket的基本概念。 ... [详细]
  • get

    MFC动态创建窗口的实现方法及注意事项

    本文介绍了在MFC下利用C++和MFC的特性动态创建窗口的方法，包括继承现有的MFC类并加以改造、插入工具栏和状态栏对象的声明等。同时还提到了窗口销毁的处理方法。本文详细介绍了实现方法并给出了相关注意事项。 ... [详细]
  • get

    Hibernate基础映射

    在说Hibernate映射前，我们先来了解下对象关系映射ORM。ORM的实现思想就是将关系数据库中表的数据映射成对象，以对象的形式展现。这样开发人员就可以把对数据库的操作转化为对 ... [详细]
  • object

    关于cuowu类的错误提示和使用AdjustmentListener的问题

    本文讨论了一个关于cuowu类的问题，作者在使用cuowu类时遇到了错误提示和使用AdjustmentListener的问题。文章提供了16个解决方案，并给出了两个可能导致错误的原因。 ... [详细]
  • get

    自动轮播，反转播放的ViewPagerAdapter的使用方法和效果展示

    自动轮播，反转播放的ViewPagerAdapter的使用方法和效果展示
    本文介绍了如何使用自动轮播、反转播放的ViewPagerAdapter，并展示了其效果。该ViewPagerAdapter支持无限循环、触摸暂停、切换缩放等功能。同时提供了使用GIF.gif的示例和github地址。通过LoopFragmentPagerAdapter类的getActualCount、getActualItem和getActualPagerTitle方法可以实现自定义的循环效果和标题展示。 ... [详细]
  • object

    SpringJdbcTemplate的使用详解

    本文详细介绍了Spring的JdbcTemplate的使用方法，包括执行存储过程、存储函数的call()方法，执行任何SQL语句的execute()方法，单个更新和批量更新的update()和batchUpdate()方法，以及单查和列表查询的query()和queryForXXX()方法。提供了经过测试的API供使用。 ... [详细]
  • object

    Java中vector的使用详解

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

    猜字母游戏

    猜字母游戏
    猜字母游戏猜字母游戏——设计数据结构猜字母游戏——设计程序结构猜字母游戏——实现字母生成方法猜字母游戏——实现字母检测方法猜字母游戏——实现主方法1猜字母游戏——设计数据结构1.1 ... [详细]
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社区 版权所有