我眼中的单例模式

最新推荐文章于 2024-04-30 16:11:30 发布

Chen_leilei

最新推荐文章于 2024-04-30 16:11:30 发布

阅读量176

点赞数

分类专栏： JAVA 文章标签： java 后端设计模式

本文链接：https://blog.csdn.net/Chen_leilei/article/details/107833081

版权

JAVA 专栏收录该内容

25 篇文章 2 订阅

订阅专栏

单例模式即内存只会创建一个对象也只创建一次对象的设计模式。

那为什么我们要使用单例呢，大家都知道频繁的创建对象会让内存飙升，而单例模式会让内存只使用这一个对象，

单例模式的类型

懒汉式：(好懒啊，什么时候用我就什么时候创建好了) 只有真正使用对象的时候才会创建单例对象

饿汉式：（好饿啊，赶紧创建出来吧）在类加载的时候，就创建好了，

懒汉式的创建方式：

public class Singleton(){

    private static Singleton singleton;

    //无参函数
    private Singleton(){
    
    }
    
    public static getInstance(){
        if(singleton==null){
        
            singleton = new Singleton();
        }
    
        return singleton
    }

}

如果在多线程的环境下，上面写的就不是那么好了，那么看他的升级版

public class Singleton(){

    private static Singleton singleton;

    //无参函数
    private Singleton(){
    
    }
    
    //加了一个锁，这下线程安全了吧
    public synchronized static getInstance(){
        if(singleton==null){
        
            singleton = new Singleton();
        }
    
        return singleton
    }

}

但是每次获取对象都要获取锁，并发的性能差到了极点了。那好吧，我改改

public class Singleton {
    
    private static Singleton singleton;
    
    private Singleton(){}
    
    public static Singleton getInstance() {
        if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
            synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化
                if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    
}

这么写就解决了并发安全和性能问题。这种写法也叫双重检验（double check）+锁（lock）,这下没问题了吧？

NONONO..咱们忽略了一点，指令重排。

这个东西可气人了。JVM在保证最后结果正确的情况下，可能不按照你写的顺序执行语句。那我们怎么办啊？一个关键字搞定

volatile 。别看他就一个关键字。他作用大着呢！l

1.使用 volatile 关键字修饰的变量，可以保证其指令执行的顺序与程序指明的顺序一致，不会发生顺序变换

2.用 volatile 关键字修饰的变量，可以保证其内存可见性，即每一时刻线程读取到该变量的值都是内存中最新的那个值，线程每次操作该变量都需要先读取该变量。

那最终的代码是什么样呢？

public class Singleton {
    
    private static volatile Singleton singleton;
    
    private Singleton(){}
    
    public static Singleton getInstance() {
        if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
            synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化
                if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    
}

下面我们来看看饿汉式

饿汉式比较简单啦

直接上代码

public class Singleton{
    
    private static final Singleton singleton = new Singleton();
    
    private Singleton(){}
    
    public static Singleton getInstance() {
        return singleton;
    }
}

你以为结束了？没有呢

还有一种写法

public enum Singleton {
    INSTANCE;
    Singleton(){
    }


    public static void main(String[] args) {
        test();
    }

    public  synchronized static void test() {
        Singleton t1 = Singleton.INSTANCE;
        Singleton t2 = Singleton.INSTANCE;
        System.out.print(t1 == t2);
    }
}

这是啥？枚举，有啥好处？

1代码少，只需要三行代码不用

2.天然的线程安全与单一实例

3.还有一点是上面那两种办法都媲美不了的。就是枚举可不怕你的反射，你的序列化反序列化来破坏我的单例。

枚举类默认继承了 Enum 类，在利用反射调用 newInstance() 时，会判断该类是否是一个枚举类，如果是，则抛出异常。

在读入 Singleton 对象时，每个枚举类型和枚举名字都是唯一的，所以在序列化时，仅仅只是对枚举的类型和变量名输出到文件中，在读入文件反序列化成对象时，使用 Enum 类的 valueOf(String name) 方法根据变量的名字查找对应的枚举对象。所以，在序列化和反序列化的过程中，只是写出和读入了枚举类型和名字，没有任何关于对象的操作。

那就到这里了。。。