- 单例模式
- 概念
- 如何设计
- 饿汉模式
- 懒汉模式
- 分析造成线程不安全的原因
- 解决方法
- 总结
单例模式
概念
单例是一种设计模式。单例指的是在全局范围内只有一个实例对象。比如在学习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修饰共享变量解决有序性问题。
继续加油~
