单例模式

最新推荐文章于 2019-08-17 12:15:50 发布
最新推荐文章于 2019-08-17 12:15:50 发布
阅读量453 收藏
点赞数
分类专栏： java专栏 文章标签： 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ddsheng1128/article/details/9181833
版权

单例模式大家并不陌生，也都知道它分为什么懒汉式、饿汉式之类的。但是你对单例模式的理解足够透彻吗？今天我带大家一起来看看我眼中的单例，可能会跟你的认识有所不同。

下面是一个简单的小实例：

[java] view plain copy print ?
  1. //简单懒汉式
  2. public class Singleton {
  4. //单例实例变量
  5. private static Singleton instance = null;
  7. //私有化的构造方法，保证外部的类不能通过构造器来实例化
  8. private Singleton() {}
  10. //获取单例对象实例
  11. public static Singleton getInstance() {
  13. if (instance == null) {
  14. instance = new Singleton();
  15. }
  17. System.out.println("我是简单懒汉式单例！");
  18. return instance;
  19. }
  20. } 
//简单懒汉式
public class Singleton {
	
	//单例实例变量
	private static Singleton instance = null;
	
	//私有化的构造方法，保证外部的类不能通过构造器来实例化
	private Singleton() {}
	
	//获取单例对象实例
	public static Singleton getInstance() {
        
	    if (instance == null) { 
	        instance = new Singleton(); 
	    }
	    
	    System.out.println("我是简单懒汉式单例！");
	    return instance;
    }
}

很容易看出，上面这段代码在多线程的情况下是不安全的，当两个线程进入if (instance == null)时，两个线程都判断instance为空，接下来就会得到两个实例了。这不是我们想要的单例。


接下来我们用加锁的方式来实现互斥，从而保证单例的实现。

[java] view plain copy print ?
  1. //同步法懒汉式
  2. public class Singleton {
  4. //单例实例变量
  5. private static Singleton instance = null;
  7. //私有化的构造方法，保证外部的类不能通过构造器来实例化
  8. private Singleton() {}
  10. //获取单例对象实例
  11. public static synchronized Singleton getInstance() {
  13. if (instance == null) {
  14. instance = new Singleton();
  15. }
  17. System.out.println("我是同步法懒汉式单例！");
  18. return instance;
  19. }
  20. } 
//同步法懒汉式
public class Singleton {
	
	//单例实例变量
	private static Singleton instance = null;
	
	//私有化的构造方法，保证外部的类不能通过构造器来实例化
	private Singleton() {}
	
	//获取单例对象实例
	public static synchronized  Singleton getInstance() {
        
        if (instance == null) { 
            instance = new Singleton(); 
        }
        
        System.out.println("我是同步法懒汉式单例！");
        return instance;
    }
}

加上synchronized后确实保证了线程安全，但是这样就是最好的方法吗？很显然它不是，因为这样一来每次调用getInstance()方法是都会被加锁，而我们只需要在第一次调用getInstance()的时候加锁就可以了。这显然影响了我们程序的性能。我们继续寻找更好的方法。


经过分析发现，只需要保证instance = new Singleton()是线程互斥就可以保证线程安全，所以就有了下面这个版本：

[java] view plain copy print ?
  1. //双重锁定懒汉式
  2. public class Singleton {
  4. //单例实例变量
  5. private static Singleton instance = null;
  7. //私有化的构造方法，保证外部的类不能通过构造器来实例化
  8. private Singleton() {}
  10. //获取单例对象实例
  11. public static Singleton getInstance() {
  12. if (instance == null) {
  13. synchronized (Singleton.class) {
  14. if (instance == null) {
  15. instance = new Singleton();
  16. }
  17. }
  18. }
  19. System.out.println("我是双重锁定懒汉式单例！");
  20. return instance;
  21. }
  22. } 
//双重锁定懒汉式
public class Singleton {
	
	//单例实例变量
	private static Singleton instance = null;
	
	//私有化的构造方法，保证外部的类不能通过构造器来实例化
	private Singleton() {}
	
	//获取单例对象实例
	public static Singleton getInstance() {
        if (instance == null) { 
            synchronized (Singleton.class) {
                if (instance == null) { 
                    instance = new Singleton(); 
                }
            }
        }
        System.out.println("我是双重锁定懒汉式单例！");
        return instance;
    }
}

这次看起来既解决了线程安全问题，又不至于每次调用getInstance()都会加锁导致降低性能。看起来是一个完美的解决方案，事实上是这样的吗？

很遗憾，事实并非我们想的那么完美。java平台内存模型中有一个叫“无序写”（out-of-order writes）的机制。正是这个机制导致了双重检查加锁方法的失效。这个问题的关键在上面代码上的第5行：instance = new Singleton(); 这行其实做了两个事情：1、调用构造方法，创建了一个实例。2、把这个实例赋值给instance这个实例变量。可问题就是，这两步jvm是不保证顺序的。也就是说。可能在调用构造方法之前，instance已经被设置为非空了。下面我们一起来分析一下：


假设有两个线程A、B

1、线程A进入getInstance()方法。

2、因为此时instance为空，所以线程A进入synchronized块。

3、线程A执行 instance = new Singleton(); 把实例变量instance设置成了非空。（注意，是在调用构造方法之前。）

4、线程A退出，线程B进入。

5、线程B检查instance是否为空，此时不为空（第三步的时候被线程A设置成了非空）。线程B返回instance的引用。（问题出现了，这时instance的引用并不是Singleton的实例，因为没有调用构造方法。）

6、线程B退出，线程A进入。

7、线程A继续调用构造方法，完成instance的初始化，再返回。


难道就没有一个好方法了吗？好的方法肯定是有的，我们继续探索！

[java] view plain copy print ?
  1. //解决无序写问题懒汉式
  2. public class Singleton {
  4. //单例实例变量
  5. private static Singleton instance = null;
  7. //私有化的构造方法，保证外部的类不能通过构造器来实例化
  8. private Singleton() {}
  10. //获取单例对象实例
  11. public static Singleton getInstance() {
  12. if (instance == null) {
  13. synchronized (Singleton.class) { //1
  14. Singleton temp = instance; //2
  15. if (temp == null) {
  16. synchronized (Singleton.class) { //3
  17. temp = new Singleton(); //4
  18. }
  19. instance = temp; //5
  20. }
  21. }
  22. }
  23. System.out.println("我是解决无序写懒汉式单例！");
  24. return instance;
  25. }
  26. } 
//解决无序写问题懒汉式
public class Singleton {
	
	//单例实例变量
	private static Singleton instance = null;
	
	//私有化的构造方法，保证外部的类不能通过构造器来实例化
	private Singleton() {}
	
	//获取单例对象实例
	public static Singleton getInstance() {
		if (instance == null) { 
			synchronized (Singleton.class) {                  //1
				Singleton temp = instance;                //2
				if (temp == null) {
					synchronized (Singleton.class) {  //3 
						temp = new Singleton();   //4    
					}
					instance = temp;                  //5      
				}
			}
		}
		System.out.println("我是解决无序写懒汉式单例！");
		return instance;
	}	
}

1、线程A进入getInstance()方法。

2、因为instance是空的 ，所以线程A进入位置//1的第一个synchronized块。

3、线程A执行位置//2的代码，把instance赋值给本地变量temp。instance为空，所以temp也为空。

4、因为temp为空，所以线程A进入位置//3的第二个synchronized块。（后来想想这个锁有点多余）

5、线程A执行位置//4的代码，把temp设置成非空，但还没有调用构造方法！（“无序写”问题）

6、如果线程A阻塞，线程B进入getInstance()方法。

7、因为instance为空，所以线程B试图进入第一个synchronized块。但由于线程A已经在里面了。所以无法进入。线程B阻塞。

8、线程A激活，继续执行位置//4的代码。调用构造方法。生成实例。

9、将temp的实例引用赋值给instance。退出两个synchronized块。返回实例。

10、线程B激活，进入第一个synchronized块。

11、线程B执行位置//2的代码，把instance实例赋值给temp本地变量。

12、线程B判断本地变量temp不为空，所以跳过if块。返回instance实例。


到此为止，上面的问题我们是解决了，但是我们突然发现为了解决线程安全问题，但给人的感觉就像身上缠了很多毛线.... 乱糟糟的，所以我们要精简一下：

[java] view plain copy print ?
  1. //饿汉式
  2. public class Singleton {
  4. //单例变量 ,static的，在类加载时进行初始化一次，保证线程安全
  5. private static Singleton instance = new Singleton();
  7. //私有化的构造方法，保证外部的类不能通过构造器来实例化。
  8. private Singleton() {}
  10. //获取单例对象实例
  11. public static Singleton getInstance() {
  12. System.out.println("我是饿汉式单例！");
  13. return instance;
  14. }
  15. } 
//饿汉式
public class Singleton {
	
	//单例变量 ,static的，在类加载时进行初始化一次，保证线程安全 
	private static Singleton instance = new Singleton();    
	
	//私有化的构造方法，保证外部的类不能通过构造器来实例化。     
	private Singleton() {}
	
	//获取单例对象实例     
	public static Singleton getInstance() {
	    System.out.println("我是饿汉式单例！");
	    return instance;
	}
}

看到上面的代码，瞬间觉得这个世界清静了。不过这种方式采用的是饿汉式的方法，就是预先声明Singleton对象，这样带来的一个缺点就是：如果构造的单例很大，构造完又迟迟不使用，会导致资源浪费。


到底有没有完美的方法呢？继续看：

[java] view plain copy print ?
  1. //内部类实现懒汉式
  2. public class Singleton {
  4. private static class SingletonHolder{
  5. //单例变量
  6. private static Singleton instance = new Singleton();
  7. }
  9. //私有化的构造方法，保证外部的类不能通过构造器来实例化。
  10. private Singleton() {
  12. }
  14. //获取单例对象实例
  15. public static Singleton getInstance() {
  16. System.out.println("我是内部类单例！");
  17. return SingletonHolder.instance;
  18. }
  19. } 
//内部类实现懒汉式
public class Singleton {
	
    private static class SingletonHolder{
        //单例变量  
        private static Singleton instance = new Singleton();
    }
    
    //私有化的构造方法，保证外部的类不能通过构造器来实例化。
    private Singleton() {
        
    }
    
    //获取单例对象实例
    public static Singleton getInstance() {
    	System.out.println("我是内部类单例！");
        return SingletonHolder.instance;
    }
}

懒汉式（避免上面的资源浪费）、线程安全、代码简单。因为java机制规定，内部类SingletonHolder只有在getInstance()方法第一次调用的时候才会被加载（实现了lazy），而且其加载过程是线程安全的（实现线程安全）。内部类加载的时候实例化一次instance。


简单说一下上面提到的无序写，这是jvm的特性，比如声明两个变量，String a; String b; jvm可能先加载a也可能先加载b。同理，instance = new Singleton();可能在调用Singleton的构造函数之前就把instance置成了非空。这是很多人会有疑问，说还没有实例化出Singleton的一个对象，那么instance怎么就变成非空了呢？它的值现在是什么呢？想了解这个问题就要明白instance = new Singleton();这句话是怎么执行的，下面用一段伪代码向大家解释一下：

[plain] view plain copy print ?
  1. mem = allocate(); //为Singleton对象分配内存。
  2. instance = mem; //注意现在instance是非空的，但是还没有被初始化。
  4. ctorSingleton(instance); //调用Singleton的构造函数，传递instance. 
mem = allocate();             //为Singleton对象分配内存。
instance = mem;               //注意现在instance是非空的，但是还没有被初始化。

ctorSingleton(instance);    //调用Singleton的构造函数，传递instance.


由此可见当一个线程执行到instance = mem; 时instance已为非空，如果此时另一个线程进入程序判断instance为非空，那么直接就跳转到return instance;而此时Singleton的构造方法还未调用instance，现在的值为allocate();返回的内存对象。所以第二个线程得到的不是Singleton的一个对象，而是一个内存对象。


以上就是就是我对单例模式的一点小小的思考跟理解，热烈欢迎各位大神前来指导批评。

ddsheng1128
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java SE程序 单例模式
01-21
Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式...
单例模式和多线程安全
dingnate的专栏
03-11 550
单例模式分三种：懒汉式单例、饿汉式单例、内部类单例、登记式单例几种。 单例模式有一下特点： 1、单例类只能有一个实例。 2、单例类必须自己自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实例。 懒汉模式不是线程安全的。 饿汉模式是线程安全的。 内部内模式利用Classloader的特 注册表模式是线程安全的同时又提供运行期指定单例。 饿汉式单例类 public
python 单例模式
pi9nc的专栏
07-21 1294
python单例模式 分类： python 2013-07-20 13:04 103人阅读 评论(0) 收藏 举报 [python] view plaincopyprint? __new__()在__init__()之前被调用，用于生成实例对象。利用这个方法和类的属性的特点可以实现设计模式的单例模式。单例模式是指创建唯一对象，单例模式设计的类只能
java与模式
Do Better Every Day
12-21 739
Java与模式 1、工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。工厂模式有以下几种形态：        （1）简单工厂（Simple Factory）模式，又称静态工厂方法模式（Static Factory Method Pattern）。       （2）工厂方法（Factory Method）模式，又称多态性工厂（
单件模式——HeadFirst设计模式学习笔记
weixin_30423977的博客
10-21 64
单件模式：确保一个类只有一个实例，并提供一个全局访问点。 特点： 单例模式确保一个实例被创建，并且任意时刻都只有一个对象。 特征是构造函数为私有，然后声明一个私有静态成员作为类对象，对外提供一个静态类方法创建该对象 在创建对象时会先判断是否已经创建，若是则直接返回已经创建的对象，若没有则创建新对象 用途： 某些对象在程序运行过程中我们只需要一个，或只能生成一个，如线程池、注...
Java 单例模式实现
01-20
饿汉式 线程安全，调用效率高，但是不能延时加载。 public class Singleton { private static Singleton instance = new ...如果方法没有 synchronized，单例没有 volatile , 则线程不安全。 public class Singleton {
单例模式1
08-08
单例模式1
singleton单例模式1
08-08
singleton单例模式1
单例模式介绍
12-15
android 六种单例模式源码介绍，反序列化解决方案，编译环境为android studio 3.0.1
JAVA 多线程处理大数据LIST
拼命微笑的专栏
07-01 7395
package com.sinosoft.audit; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ScheduledThre
WSSERVLET11:failed to parse runtime descriptor: java.lang.LinkageError
拼命微笑的专栏
08-24 3381
MyEclipse 建立的JAX-WS webservice工程，到其他机器tomcat中无法启动--LinkageError 错误内容： 严重: WSSERVLET11:failed to parse runtime descriptor: java.lang.LinkageError: JAXB 2.0 API is being loaded from the bootst
【Windows 8】pid为4的system进程占用80端口的解决办法
拼命微笑的专栏
07-30 3381
【Windows 8】pid为4的system进程占用80端口的解决办法 1、运行cmd，然后输入netstat -a -n -o，回车； 2、查看开头几行包含0.0.0.0:80的那一行最后的pid，为几个数字，把这几个数字记下来； 3、启动“任务管理器”——“进程”，在“工具栏”——“选择列”前面的框里打上勾； 4、然后找到与刚才那个pid对应的是哪个程序，很容易就会找到，
java中如何获取项目各个目录下的文件
拼命微笑的专栏
07-06 3301
平时写程序的时候,很多时候提示文件找不到,而抛出了异常,现在整理如下 一 相对路径的获得 说明:相对路径(即不写明时候到底相对谁)均可通过以下方式获得（不论是一般的java项目还是web项目） String relativelyPath=System.getProperty("user.dir"); 上述相对路径中，java项目中的文件是相对于项目的根目录 web项目中的文件路径视不
PowerDesigner 12.5破解方法
拼命微笑的专栏
08-17 3207
PowerDesigner 12.5破解方法 PowerDesigner 12.5破解方法 一、下载 1 、 PowerDesigner 12.5 官方下载地址http://download.sybase.com/eval/PowerDesigner/powerdesigner125_eval.exe,大小 125 MB 若无法下载请到脚本之家下载 2 、所用到的破解文件 lic...
将tomcat添加为linux系统服务
拼命微笑的专栏
08-28 2141
前言 　　在博客 --》virtualBox安装centos，并搭建tomcat中，讲到了centos下搭建tomcat环境，发现启动tomcat不是那么方便，要是忘记路径了，那就更麻烦了！当然了，忘记路径了也还是有许多方式找回来的，那么有没有什么方式将tomcat设置成系统服务了，就像service iptables start一样用service tomcat start来启动tomcat了...
Java面试宝典2014版
拼命微笑的专栏
03-17 2030
一. Java基础部分......................................................................................................2 1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？.....2 2、Java有没有goto?....................
JAVA WEB 后台开发自己用的UI admin 框架
拼命微笑的专栏
03-22 1776
前端最火热的开发框架 1：http://jui.org/Dwz富客户端 2: Bui http://www.builive.com/ 3:amazeui 批量模板 4: easyUi 5:AdminLTE 入门教程http://blog.csdn.net/u014451076/article/details/51037730 更多参加知乎-关于后端程序...
IReport与JasperReport生成HTML报表的问题
拼命微笑的专栏
07-19 1740
笔者最近做的一个基于J2EE的Web项目，使用IReport与JasperReport作为Web报表的解决方案，在使用Html报表形式进行打印时出现如下问题。 1．问题描述：使用JasperReport生成Html报表后，数据显示正确，但各种线条显示不出来(若中文显示不出来请参见文章：iReport与JasperReport中文支持全面解决)。 产生原因：在生成HTML页面时JRHtmlExp
java设计模式单例模式
最新发布
03-14
单例模式是一种常用的设计模式，它保证一个类只有一个实例，并提供一个全局访问点。在Java中，实现单例模式有多种方式，下面是两种常见的实现方式： 1. 饿汉式单例模式： 在类加载时就创建实例，保证了线程安全，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值