浅析Java并发中的单例模式

一、单例模式简介

单例模式,是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中,应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。在java代码中,通常new关键字创造出来的对象,对系统的开销一般都挺大的。所以在某些情况下,单例的实现也是应对系统优化的一种解决办法。

二、单例模式的实现

常见的单例有这几种实现

  • 饿汉式
  • 饱汉式
  • 双重校验
  • 静态内部类

1、饿汉式

先来介绍饿汉式,饿汉式,顾名思义,就是一进入这个类,该类的实例就被初始化完成了。接下来来看下代码。

public class Demo {
	private static Demo h = new Demo();
	private Demo(){
	}
	public static Demo getInstance(){
		return h;
	}
}
复制代码

代码也和简单,就是直接构造一个私有的构造器,然后在建立一个成员变量,顺便实例化该类,在调用该类的getInstance方法,当然前面也说过是一进入这个类,

该类的实例就被创建完成,所以也可以利用类的加载顺序来编写这个代码。比如 A类是B类的子类,在初始化A类的实例的时候,会先去父类B中去,看看有没有静态块和静态成员变量(静态方法只有被调用时才会加载,且只会被加载一次),若有则先去加载B类的静态块和静态成员变量,再加载A类的。之后会去调用B的构造器,最后才会调用本类对应的构造器。

所以我们可以在静态代码块中实例化。如下代码

public class Demo {
	private static Demo h = null;
	private Demo(){
	}
	static{
		h = new Demo();
	}
	public static Demo getInstance(){
		return h;
	}
}
复制代码

该种实现的单例是线程安全的。当然由于它会提前初始化,所以会提前占用一些系统资源。

2、饱汉式

饱汉式的构造实例的时候与饿汗式相反,它只有在第一次需要的时候才会去构造实例。具体实现代码如下 

public class Demo {
	private static Demo h = null;
	private Demo(){
	}
	public static Demo getInstance(){
		if(h == null){
			//1
			h = new Demo();
			//2
		}
		return h;
	}
}
复制代码

饱汉式最常见的的编写方式就是上述代码,对于刚了解单例模式的人来说,饱汉式就写完了,不过在单线程环境也确实可以说是写完了,A线程在获取实例,第一次获取时,看见为null,进行初始化,第二次,不是null,直接返回。这也是一种很理想的流程。但是值得注意的是,在多线程下,它就值得推敲了。比如看下面例子

  • 线程A:嘿嘿!我已经走到了2,这初始化的好处我就要独占了,想想都鸡冻,我要去初始化Demo类的实例了,啦啦啦。
  • 线程B:哈哈!线程A那个SD,我都走到了1,它竟然还没发现我,还想独占Demo的实例化,没门!!

旁白:线程A还完成了对该类实例的初始化,线程B也进入了对该实例的构造中,

因此,线程A和线程B都同时初始化了该实例,这也不满足单例的条件。

于是有人很自然的想到,加锁。如下

public class Demo {
	private static Demo h = null;
	private Demo(){
	}
	public synchronized static Demo getInstance(){
		if(h == null){
			h = new Demo();
		}
		return h;
	}
}
复制代码

这样确实可以防止多线程环境造成多个实例。但的缺点是每一次获取都去加锁,会对性能有一定的损失。所以有了双重校验锁。

3、双重校验

双重校验,就是在获取单例的时候,对加锁的方式进行了改变,它不在方法上加锁,它对代码块进行加锁,这样的效率比饱汉式要高。具体代码如下

public class Demo {
	private static Demo h = null;
	private Demo(){
	}
	public static Demo getInstance(){
		if(h == null){
			//1
			synchronized (new Object()) {
				//2
				if(h == null){
					h = new Demo();
				}
			}
		}
		return h;
	}
}
复制代码

也许有人看了以上代码后会有疑问,要加上两个if判断干嘛?加一个不行吗,比如如下

public class Demo {
	private static Demo h = null;
	private Demo(){
	}
	public static Demo getInstance(){
		if(h == null){
			//1
			synchronized (new Object()) {
				//2
				h = new Demo();
			}
		}
		return h;
	}
}
复制代码

这样不也对进行实例化的时候加锁了吗?也可以保证线程安全啊!

看这个例子

  • 线程A:嘿嘿!我已经走到了2,咦!竟然还有锁,更好了,这初始化的好处我就要独占了,想想都鸡冻,我要去初始化Demo类的实例了,啦啦啦。
  • 线程B:哈哈!线程A那个SD,我都走到了1,它竟然还没发现我,还想独占Demo的实例化,没门!!卧槽,静态被线程A那个SD上锁了,哎等等吧!
  • 线程B:咦!锁的钥匙又回来了,哎,没希望了,希望能给我喝点汤。n秒后,B处于惊讶中,没想到我还能初始化。哈哈哈。

为啥双重会被认为是线程安全的。看这个例子

  • 线程A:嘿嘿!我已经走到了2,咦!竟然还有锁,更好了,这初始化的好处我就要独占了,想想都鸡冻,我要去初始化Demo类的实例了,啦啦啦。
  • 线程B:哈哈!线程A那个SD,我都走到了1,它竟然还没发现我,还想独占Demo的实例化,没门!!卧槽,静态被线程A那个SD上锁了,哎等等吧!
  • 线程B:咦!锁的钥匙又回来了,哎,没希望了,希望能给我喝点汤。n秒后,B处于崩溃中,没想到竟然还有if(h == null)这个大门,我进不去了,呜呜呜。

值得注意的是,该种产生单例的方式也会有线程安全的问题,学过java的都知道,java中在new对象的时候,并不是原子操作,它有以下三个大概步骤

  • 分配内存空间
  • 初始化对象
  • 将内存地址赋给引用h

由于重排序原因(关于重排序的知识,可自行网上搜索),可能在new对象时,第二步和第三步发生了交换,导致错误发生,理由是,此时的h是一个地址,但它

还没完成初始化,如下例子

  • 线程A:嘿嘿!我已经走到了2,咦!竟然还有锁,更好了,这初始化的好处我就要独占了,想想都鸡冻,我要去初始化Demo类的实例了,啦啦啦。
  • 线程B:哈哈!线程A那个SD,我都走到了1,它竟然还没发现我,还想独占Demo的实例化,没门!!卧槽,静态被线程A那个SD上锁了,哎等等吧!
  • 线程B:咦!锁的钥匙又回来了,哎,没希望了,希望能给我喝点汤。n秒后,B处于崩溃中,没想到竟然还有if(h == null)这个大门。
  • 线程B:只能认命了,我只能访问Demo对象玩玩,噗噗噗,竟然出错了。。

其原因就如上述所说,发生了重排序导致的错误发生,当然,这个错误不一定经常发生。所有这时应该想的是怎么防止重排序。

于是有人就想到了java中的volatile关键字来禁止代码的重排序,当然它还有保证可见性的功能,但不能和synchronized一样还能保证原子性。

加了volatile关键字后,这样才算真的线程安全,具体代码如下

public class Demo {
	private volatile static Demo h = null;
	private Demo(){
	}
	public static Demo getInstance(){
		if(h == null){
			synchronized (new Object()) {
				h = new Demo();
			}
		}
		return h;
	}
}
复制代码

4、静态内部类

静态内部类就是在该类的内部实现一个静态内部类,内部类里来实现该类的实例化,具体代码如下

public class Demo {
	private volatile static Demo h = null;
	private Demo(){
	}
	public static Demo getInstance(){
		return InnerDemo.h;
	}
	//内部类
	private static class InnerDemo{
		private final static Demo h = new Demo();
	}
}
复制代码

内部类的原理是利用了类加载器classloader机制来保证初始化h时只有一个线程,这样也就保证了线程的安全性 。同时也不像饿汗式一样,一进入该类就触发实例初始化。内部类虽然是static,但只有在return InnerDemo.h时才会触发该内部类的加载,也是懒加载的一种。

读者福利:

分享免费学习资料

针对于还会准备免费的Java架构学习资料(里面有高可用、高并发、高性能及分布式、Jvm性能调优、MyBatis,Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料) 为什么某些人会一直比你优秀,是因为他本身就很优秀还一直在持续努力变得更优秀,而你是不是还在满足于现状内心在窃喜!希望读到这的您能点个小赞和关注下我,以后还会更新技术干货,谢谢您的支持!

资料领取方式:加入粉丝群963944895,私信管理员即可免费领取

转载于:https://juejin.im/post/5ca89d8ce51d456dbd106860

你可能感兴趣的:(浅析Java并发中的单例模式)