编程(40)----------单例模式

在简单总结单例模式之前, 需要了解一下背景知识-----为何会有单例模式?

想象一个这样的场景, 打游戏的时候, 尝试很多次, 都未通关. 这种情况下是否会考虑查一下攻略? 一个好的攻略甚至可能连每一关的每一个场景由多少只怪物都说的清清楚楚. 再比如, 在以前上学的时候, 为了方便理解和使用一些解题技巧, 是不是会有一些口诀? 例如, 奇变偶不变, 符号看象限. 亦或者,为了能够下棋下的更好, 可能会尝试去看看棋谱. 棋谱里会把常见的开局解法给一一列举出来.

单例模式也是一个道理. 就跟上述的一样, 是为了方便代码的规范所做出的一些明确的规定,或者说代码的写法. 以此提高写代码的效率. 这些模式种类很多, 单例模式只是其中的一个. 顾名思义,单例模式就是只允许创建一个实例的模式.

代码写法有两种: 饿汉模式和懒汉模式

//饿汉模式
class Singleton{
    //先将实例创建出来
    private static Singleton instance = new Singleton();

    //若要使用唯一实例, 通过统一的方法
    public static Singleton getInstance(){
        return instance;
    }

    //将构造方法设为私有, 则无法在该类外使用该构造方法
    private Singleton(){
    }
}

public class demo3 {
    public static void main(String[] args) {

    }
}

//懒汉模式
class Singleton{
    //先将实例创建出来
    private static Singleton instance = null;

    //若要使用唯一实例, 通过统一的方法
    public static Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }

    //将构造方法设为私有, 则无法在该类外使用该构造方法
    private Singleton(){
    }
}

public class demo3 {
    public static void main(String[] args) {

    }
}

代码本身并不复杂, 涉及到的也是一些简单的Java语法. 但是, 存在一个问题: 这两种模式是否线程安全?

在此之前, 得清楚衡量线程是否安全, 其中一个重要的指标就是, 是否该代码或者说线程只进行了读操作. 若既有读操作又有其他操作, 如写改操作. 那这个线程多半是不安全的.

再回到这俩个模式的代码中. 不难看出懒汉模式存在一个if语句的判定, 这其实就是读操作. 要先读入才能进行判定改写, 因此懒汉模式线程不安全. 反之, 饿汉模式只有读操作, 是安全的.

基于以上的结论, 假设要在多线程中使用懒汉模式. 就必须将其进行优化.

首先就从判定改写入手. 在多线程中, 由于读入, 判定, 改写的操作不具有原子性, 是分开的操作. 很有可能一个线程刚判定完, 为null, 另一个线程也开始判定, 结果也为null. 在这种情况下二者都会依照代码在此基础上new一个对象. 但是这实际上是违背了单例模式的规则. 因此要对整个过程进行加锁操作.

  synchronized (SingletonLazy.class) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }

其次, 在线程很多的情况下, 需要每次都进行if判定是否为空吗? 很明显不需要, 单例模式只存在一个实例. 也就是说无需每次都加锁进行if判定, 效率过低. 当已经有某个线程new了一个对象以后,直接返回对象即可, 因此可以将代码进行再次优化:

public static SingletonLazy getSingletonLazy(){
        if (instance == null) {
            synchronized (SingletonLazy.class) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }

除此以外, 当线程非常多且代码没有什么变化的时候, 系统自身会优化, 即发生内存可见性问题. 还有可能发生代码执行顺序调换的问题. 为解决以上问题, 使用volatile关键字一次性解决. 因此综合以上优化, 懒汉模式的多线程代码就差不多可以写出来了:

//懒汉模式
class SingletonLazy{
    private volatile static SingletonLazy instance = null;

    public static SingletonLazy getSingletonLazy(){
        if (instance == null) {
            synchronized (SingletonLazy.class) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }

    private SingletonLazy(){
    }
}

public class demo4 {
    public static void main(String[] args) {
    }
}

------------------------------最后编辑于2023.6.1晚上八点左右