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

x33g5p2x  于2022-02-07 转载在 Java  
字(2.2k)|赞(0)|评价(0)|浏览(267)

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对象一直占用着这段内存

懒汉与饿汉式如何选择

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

相关文章

最新文章

更多