浅析Java并发中的单例模式

r囧r小猫 2022-10-01 10:54 215阅读 0赞

# 一、单例模式简介 #

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。在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