设计模式-单例模式

想睡觉的小码农

已于 2023-10-23 14:03:54 修改

阅读量362

点赞数 1

分类专栏： JUC 设计模式文章标签：单例模式

于 2021-07-08 00:12:20 首次发布

本文链接：https://blog.csdn.net/TT_130616/article/details/118559505

版权

JUC 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

设计模式

3 篇文章 0 订阅

订阅专栏

单例模式是一种常用的设计模式，并且是面试中常问的一种设计模式，这篇文章就整理一下本人学习到的几种单例模式的设计

1、饿汉式

饿汉式，顾名思义就是一上来就创建单例实例。

class HungerSingleton{

    //类加载时就实例化
    private static final HungerSingleton instance= new HungerSingleton();

    //构造函数私有化
    private  HungerSingleton(){

    }
    //每次返回的都是初始化时new的对象实例
    public static HungerSingleton getInstance(){
        return instance;
    }

}

饿汉式创建实例本身是线程安全的。因为单例的实例被声明成 static 和 final 变量了，在第一次加载类到内存中时就会初始化，但是它不是一种懒加载模式，单例会在加载类后一开始就被初始化，即使客户端没有调用 getInstance()方法，会有浪费空间的情况。饿汉式的创建方式在一些场景中将无法使用：如果 Singleton 实例的创建是依赖参数或者配置文件的，在 getInstance() 之前必须调用某个方法设置参数给它，那样这种单例写法就无法使用了。

2、懒汉式

2.1 经典的懒汉式，线程不安全

class LazySingleton{
    
    //初始化的时候不会new对象
    private static LazySingleton instance;

    //构造函数私有化
    private  LazySingleton(){

    }
    //每次返回的都是初始化时new的对象实例
    public static LazySingleton getInstance(){
        if(instance==null){//如果还没有实例化，那就实例化一个
            instance = new LazySingleton();
        }
        return instance;
    }

}

这种懒汉式的写法是线程不安全的。因为多个线程如果同时执行到getinstance方法中的if判断中，那么就会都认为是null的，就会new出来多个对象。

我们可以测试一下：

public class single{
    public static void main(String[] args) {
        for (int i = 0; i <10; i++) {//十个线程同时执行getInstance
            new Thread(()->{
                try {
                    System.out.println(LazySingleton.getInstance());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }


    }
}
class LazySingleton{

    //初始化的时候不会new对象
    private static LazySingleton instance;

    //构造函数私有化
    private  LazySingleton(){

    }
    //每次返回的都是初始化时new的对象实例
    public static LazySingleton getInstance() throws InterruptedException {
        if(instance==null){
            TimeUnit.SECONDS.sleep(3);//假如每个线程执行到这都sleep3秒，这里是模拟多个线程同时执行到这个位置
            instance = new LazySingleton();
        }
        return instance;
    }

}

输出结果：

juctest.single.LazySingleton@3996d457
juctest.single.LazySingleton@7e807af7
juctest.single.LazySingleton@6e5802d8
juctest.single.LazySingleton@3a8b3c40
juctest.single.LazySingleton@43d83830
juctest.single.LazySingleton@33ca79ec
juctest.single.LazySingleton@531ebd8d
juctest.single.LazySingleton@332b9c83
juctest.single.LazySingleton@4cc3632
juctest.single.LazySingleton@7bb19dc6

可以看出多个线程new出了多个实例，这需要加锁解决

2.2方法加锁的懒汉式（线程安全）

class LazySingleton1{

    //初始化的时候不会new对象
    private static LazySingleton1 instance;

    //构造函数私有化
    private  LazySingleton1(){

    }
    //每次返回的都是初始化时new的对象实例
    public static synchronized LazySingleton1 getInstance() throws InterruptedException {
        if(instance==null){
            instance = new LazySingleton1();
        }
        return instance;
    }

}

这样肯定可以保证线程安全，因为同一时间只能有一个线程去执行getInstance方法，但是这种并不高效。其实同步操作只需要在第一次调用时（new实例对象的时候）才被需要。这就引出了双重检验锁。

2.3DCL双重检验锁

双重检验锁模式，是一种使用同步块加锁的方法。程序员称其为双重检查锁，因为会有两次检查 instance == null，一次是在同步块外，一次是在同步块内。

那为什么在同步块内还要再检验一次？因为可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。

class LazySingletonDcl{

    //初始化的时候不会new对象
    private static LazySingletonDcl instance;

    //构造函数私有化
    private  LazySingletonDcl(){
    }
    public static  LazySingletonDcl getInstance() {
        if(instance==null){//第一次检验是否为null
            synchronized(LazySingletonDcl.class) {
                if(instance==null){//加锁后再检验一次是否为空
                    instance = new LazySingletonDcl();
                }
            }
        }
        return instance;
    }

}

这种懒汉式也不是完美的。因为instance = new Singleton()这句，不是一个原子操作，事实上虚拟机将这个new对象的过程分为下面 3 件事情。

给 instance 分配内存
调用 Singleton 的构造函数来初始化成员变量
将instance对象指向分配的内存空间（执行完这步 instance == null就不成立了）

正常顺序执行这三条是没有问题的，但是在 JVM 中存在指令重排序的优化。如果没有依赖关系的指令之间的执行顺序是不一定的，也就是说上面的第2步和第3步的顺序是不能保证的，最终的执行顺序可能是 123 也可能是 132。如果是按照132执行的，那么在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了，但是此时对象还没有调用构造函数初始化，接下来线程二会直接返回 instance，然后使用，然后顺理成章地报错，因为得到的实例对象还没有初始化。

因为volatile关键字通过在指令前后加内存屏障的方式禁止指令重排序，所以我们只需要将 instance 变量声明成 volatile 就可以完成一个相对完美的双重检索机制的懒汉式单例模式的设计

class LazySingletonDcl{

    //初始化的时候不会new对象,禁止指令重排序
    private static volatile LazySingletonDcl instance;

    //构造函数私有化
    private  LazySingletonDcl(){
    }
    public static  LazySingletonDcl getInstance() {
        if(instance==null){//第一次检验是否为null
            synchronized(LazySingletonDcl.class) {
                if(instance==null){//加锁后再检验一次是否为空
                    instance = new LazySingletonDcl();//操作不是原子性的，可能会出现指令重排
                }
            }
        }
        return instance;
    }

}

2.4静态内部类的实现懒汉式

public class Singleton {  
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE; 
    }  
}

这种写法使用JVM本身机制保证了线程安全问题

因为内部类SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它是懒汉式的。

这以上的写法除了2.1都是线程安全的，但是有不是完全的，因为java中的反射，可以利用反射去获取构造方法，从而去new出多个单例模式类的对象

枚举类是反反射的。

2.5枚举

枚举的写法非常的简单，并且是线程安全的，我们可以通过EnumSingleton.INSTANCE来访问实例。创建枚举默认就是线程安全的,并且还能防止反序列化导致重新创建新的对象。

public enum EnumSingleton{
    INSTANCE;
}

想睡觉的小码农

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
设计模式-单例模式

单例模式是一种常用的设计模式，并且是面试中常问的一种设计模式，这篇文章就整理一下本人学习到的几种单例模式的设计1、饿汉式饿汉式，顾名思义就是一上来就创建单例实例。class HungerSingleton{ //类加载时就实例化 private static final HungerSingleton instance= new HungerSingleton(); //构造函数私有化 private HungerSingleton(){ }
复制链接

扫一扫

专栏目录