单例模式
概念
单例是一种设计模式。单例指的是在全局范围内只有一个实例对象。比如在学习JDBC编码时使用的DataSource,定义了数据库的用户名,密码和连接串,定义好这些属性之后就可以通过DataSource的实例对象获取数据库连接。设计模式是大牛们根据以往的程序设计经验,总结出的一套方法,类似于棋谱。
如何设计
1.口头约定
对外提供一个方法,要求大家使用这个对象时,通过这个方法来获取。只要有人参与的事都不太靠谱,所以不能采用。
2.使用编程语言本身的特性来处理
首先要分析清楚在Java中哪些对象是全局唯一的。
①.class对象,比如String.class;
②用static修饰的变量是类的成员变量。所有的实例对象访问的都i是同一个成员变量;
通过类对象和static配合可以实现单例的目的。
public class Demo01_Singleton {
public static void main(String[] args) {
//验证单例是否正确
Singleton singleton01 = new Singleton();
Singleton singleton02 = new Singleton();
Singleton singleton03 = new Singleton();
//分别打印
System.out.println(singleton01.getInstance());
System.out.println(singleton02.getInstance());
System.out.println(singleton03.getInstance());
}
}
public class Singleton {
//用static修饰变量,变量就是自己,并赋初值
private static Singleton instance = new Singleton();
//提供一个对外获取实例对象的方法
public Singleton getInstance(){
return instance;
}
}
上述示例打印出的结果相同。instance在类加载时就完成初始化,所有的类对象之间共享这个实例,这样就完成了一个简单的单例模式。还可以进一步优化。既然是单例,通过new的方式获取对象是有歧义的,所以就不能让外部new这个对象。可以私有化构造方法来实现。
public class Demo01_Singleton {
public static void main(String[] args) {
//通过静态方法调用,获取单例
Singleton singleton01 = Singleton.getInstance();
Singleton singleton02 = Singleton.getInstance();
Singleton singleton03 = Singleton.getInstance();
//分别打印
System.out.println(singleton01);
System.out.println(singleton02);
System.out.println(singleton03);
}
}
public class Singleton {
//用static修饰变量,变量就是自己,并赋初值
private static Singleton instance = new Singleton();
//构造方法私有化
private Singleton(){
}
//提供一个对外获取实例对象的方法
public static Singleton getInstance(){
return instance;
}
}
饿汉模式
类似于上述这种类一加载就完成初始化的方式称为饿汉模式。书写简单,不易出错。
懒汉模式
为了避免程序一启动就浪费过多的系统资源,当程序要使用这个对象时再对他进行初始化,这种方式称为懒汉模式。
public class Demo02_SingletonLazy {
public static void main(String[] args) {
SingletonLazy singletonLazy01 = SingletonLazy.getInstance();
SingletonLazy singletonLazy02 = SingletonLazy.getInstance();
SingletonLazy singletonLazy03 = SingletonLazy.getInstance();
//打印
System.out.println(singletonLazy01);
System.out.println(singletonLazy02);
System.out.println(singletonLazy03);
}
}
public class SingletonLazy {
//定义类成员变量
private static SingletonLazy instance = null;
//构造方法私有化
private SingletonLazy(){}
public static SingletonLazy getInstance(){
//在获取成员变量时,判断一下是否已被创建
//如果没创建再创建
if(instance == null){
instance = new SingletonLazy();
}
return instance;
}
}
上面这个懒汉模式的示例在单线程环境下不会出错,打印出的结果相同,但是在多线程环境下可能会出现错误。
public class Demo03_SingletonLazyThread {
public static void main(String[] args) {
//创建多个线程并获取单例对象
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(() -> {
//获取单例对象并打印
SingletonLazy instance = SingletonLazy.getInstance();
System.out.println(instance);
});
//启动线程
thread.start();
}
}
}
public class SingletonLazy {
//定义类成员变量
private static SingletonLazy instance = null;
//构造方法私有化
private SingletonLazy(){}
public static SingletonLazy getInstance(){
//在获取成员变量时,判断一下是否已被创建
//如果没创建再创建
if(instance == null){
instance = new SingletonLazy();
}
return instance;
}
}
比如上述示例中,10个线程里打印出的instance对象不全是同一个对象,不符合预期,出现了线程不安全的现象。
分析造成线程不安全的原因
可能存在以下这种情况:线程1先将instance加载(LOAD)到自己的工作内存中,LOAD的值为null;此时线程1被调离CPU,线程2调入CPU;线程2此时LOAD的值也是null,比较(CMP)之后,初始化了一个instance对象,相当于给它分配了(ASSIGN)一个内存空间,然后保存(STORE)到主内存中。此时线程2执行完毕,继续执行线程1中的指令。线程1比较自己工作内存中的值为null,也初始化一个新的对象,然后再保存到主内存中。所以在多线程环境下,多个线程有可能创建多个实例,出现覆盖现象。
解决方法
在单例模式下,要保证任何时候都只能出现一个有效对象。所以在多线程环境下要给代码加锁。那加锁的范围该如何确定?
方法1:给整个方法加锁,可以解决这个问题;
public synchronized static SingletonLazy getInstance(){
//在获取成员变量时,判断一下是否已被创建
//如果没创建再创建
if(instance == null){
instance = new SingletonLazy();
}
return instance;
}
方法2:在方法内部加锁。此时有两种情况:一种是只给初始化对象的语句加锁,一种是给整个if语句块加锁。这两种加锁的方式效果也会不同。
情况1:只给初始化对象的语句加锁
public static SingletonLazy getInstance(){
//在获取成员变量时,判断一下是否已被创建
//如果没创建再创建
if(instance == null){
synchronized (SingletonLazy.class){
instance = new SingletonLazy();
}
}
return instance;
}
虽然加了锁,但是这种情况这种情况的加锁并没有阻挡多线程里的if语句判空,都将初始化实例对象和存储执行了两次,发生了覆盖现象,依然会有线程安全问题。
情况2:给整个if代码块加锁
public static SingletonLazy getInstance(){
//在获取成员变量时,判断一下是否已被创建
//如果没创建再创建
synchronized (SingletonLazy.class){
if(instance == null){
instance = new SingletonLazy();
}
}
return instance;
}
此时让synchronized的包裹范围指定为整个初始化过程,可以达到预期的效果,与在方法定义中加synchronized是等价的。
目前来看这些解决方法是符合预期的,但是可以做进一步优化。以现在的写法,只要调用getInstance()方法,都需要参与锁竞争,频繁的进行用户态和内核态的切换,非常消耗资源的,相当于从用户态进入了内核态。在整个过程中,目的是让整个初始化的过程只执行一次,所以只需要让synchronized代码块在整个过程中执行一次就行。
用户态:Java层面,在JVM中执行的代码;
内核态:执行的是CPU指令。这里加了synchronized参与锁竞争之后就从应用层面进入到了系统层面。
public static SingletonDCL getInstance(){
//为了让后面线程调用该方法时,如果实例已经被创建,不再获取锁,直接返回实例
if(instance == null){
synchronized (SingletonDCL.class){
//完成初始化操作,只执行一次
if(instance == null){
instance = new SingletonDCL();
}
}
}
return instance;
}
在这个优化中,内层的if语句是为了完成初始化操作,只执行一次。而外面的if判断语句是为了让后面线程调用该方法时,如果实例已经被创建,不再获取锁,直接返回实例,让用户态来完成自己的事,避免锁竞争造成的资源浪费。这种用两层if判断的方式叫双重检查锁,两层if的功能是不一样的。
还可以继续优化。在之前多线程的线程安全中介绍过synchronized只能保证原子性和内存可见性,不能保证有序性。初始化的过程并不是一条指令。在整个初始化过程中,经历了如下阶段:
①在内存中开辟一片空间;
②初始化的对象的属性(数据);
③把内存中的地址赋给instance变量。
程序在正常执行的过程中是按照①②③这个顺序执行的。由于①和③是两个强相关的执行过程,②则是一个单独的执行过程,所以编译器或CPU就有可能进行指令重排序,使执行过程变为①③②,这样其他线程就有可能拿到一个创建了一半的对象,也就是第②步还没执行完,那么这个对象就是一个不安全的对象。所以需要用volatile修饰变量,禁止指令重排序。
public class Demo04_SingletonDCL {
public static void main(String[] args) {
//创建多个线程并获取单例对象
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(() -> {
//获取单例对象并打印
SingletonDCL instance = SingletonDCL.getInstance();
System.out.println(instance);
});
//启动线程
thread.start();
}
}
}
public class SingletonDCL {
//定义类成员变量
private volatile static SingletonDCL instance = null;
//构造方法私有化
private SingletonDCL(){}
public static SingletonDCL getInstance(){
//为了让后面线程调用该方法时,如果实例已经被创建,不再获取锁,直接返回实例。
if(instance == null){
synchronized (SingletonDCL.class){
//完成初始化操作,只执行一次
if(instance == null){
instance = new SingletonDCL();
}
}
}
return instance;
}
}
总结
🐼工作中可以使用饿汉模式,因为书写简单不容易出错;
🐼饿汉模式在程序加载时完成初始化,但是由于计算资源有限,为了节约资源,使用懒汉模式加载;
🐼懒汉模式就是在使用对象的时候再去完成初始化操作;
🐼懒汉模式在多线程环境下可能出现线程不安全的问题;
🐼那么就需要使用synchronized包裹初始化的代码块;初始化代码只执行一次,后续的线程在调用getinstance()方法时,依然会产生锁竞争,频繁进行用户态和内核态的切换,非常浪费计算资源;
🐼这时可以使用Double Check Lock(DCL)的方式在外层加非空校验,避免无用的锁竞争;
🐼synchronized解决了原子性、内存可见性问题,再使用volatile修饰共享变量解决有序性问题。
继续加油~