Java常用设计模式—单例模式

GoF23 （二十三种设计模式）可按照：创建型模式、结构性模式、行为型模式三类

创建型模式：

• 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式

结构性模式：

• 适配器模式、桥接模式、装饰模式、外观模式、享元模式、代理模式

行为型模式：

• 模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式

初学设计模式：让我们从单例模式开始：

一、单例模式

单例模式使⽤场景：

• 业务系统全局只需要⼀个对象实例，⽐如发号器、 redis 连接对象等
• Spring IOC容器中的 bean 默认就是单例
• spring boot 中的controller、service、dao层中通过 @Autowired的依赖注⼊对象默认都是单例的

单例模式分类:

• 懒汉：就是所谓的懒加载，延迟创建对象，需要用的时候再创建对象
• 饿汉：与懒汉相反，提前创建对象

1、饿汉式单例

类加载的时候直接创建对象，不管对象是否会用到！

package com.sqx.gof.single;

/***
 * 饿汉式单例，类加载的时候直接创建对象，不管对象是否会用到！
 *
 * 存在问题：对象如果没有被使用那么，其中data1~4 会占用我们的内存！
 */

public class HungrySingle {

    private byte[] data1 = new byte[1024*1024] ;
    private byte[] data2 = new byte[1024*1024] ;
    private byte[] data3 = new byte[1024*1024] ;
    private byte[] data4 = new byte[1024*1024] ;

    private HungrySingle(){   //私有构造，只能再类的内部使用，外部不可通过new创造对象

    }

    private static HungrySingle  HUNGRY = new HungrySingle();  //类加载的时候执行

    public static HungrySingle getInstance(){
        return HUNGRY ;
    }
}

2、懒汉式单例

需要获取对象的时候，才去创建对象！

package com.sqx.gof.single;

/***
 * 懒汉式单例
 */
@SuppressWarnings("ALL")
public class LazySingle {

    private LazySingle(){  //私有化构造
        System.out.println("当前线程名称：" + Thread.currentThread().getName());
    }

    private static LazySingle Lazy ;

    public static LazySingle getInstance(){  //调用该方法获取对象的时候，才去创建对象！
        if (Lazy == null) {
              Lazy = new LazySingle();
    }
            return Lazy ;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10 ; i++) {
            new Thread(() -> {
                getInstance() ;           //创建十个线程去测试！
            }).start();
        }
    }
}

发现上述代码存在问题如下：

我们发现在多线程的情况下，会发生线程安全问题！

需要加锁，保证我们的线程安全问题 ,这里我们使用的是DCL（double check Lock）双检锁

    public static LazySingle getInstance(){  //调用该方法获取对象的时候，才去创建对象！
        if (Lazy == null) {
            synchronized (LazySingle.class){
                if (Lazy == null){
                    Lazy = new LazySingle();
                }
            }
    }
            return Lazy ;
}

看着结果是没问题了，但是在多线程情况下，由于new对象不是原子性操作，上述代码仍然存在指令重排的问题

我们先看一下new 的字节码指令：

// 通过这个复制的引用调用它的构造方法
21: invokespecial #4 // Method "<init>":()V
// 最开始的这个引用用来进行赋值操作
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;

此时我们的发生指令重排，先执行赋值操作，将空的实例对象返回（此时Lazy实例已经有值了），然后执行构造初始化对象！

就在我们的的初始化执行一半，线程t2过来了，发现Lazy不为null，执行 return Lazy;我们此时返回还是未被初始化的对象，所

以问题就此发生！！

通过volatile解决指令重排问题即可：

   private static volatile LazySingle Lazy ;

对volatile修饰的变量进行写操作的时候，在写操作后加上内存屏障，使得写屏障之前的代码不会发生指令重排！

小结

饿汉式单例模式，当类加载的时候就直接实例化对象，因此不需要考虑线程安全问题。

• 优点：实现简单，不需要考虑线程安全问题
• 缺点：不管有没有使用该对象实例，instance对象一直占用着这段内存

懒汉与饿汉式如何选择？

• 如果对象内存占用不大，且创建不复杂，直接使用饿汉的方式即可
• 其他情况均采用懒汉方式(优选)