设计模式之单例模式、多例模式

算法于数据结构、设计模式是永远不会过时的话题，最近在脉脉上看到个帖子关于单例的，想着也好长时间没写了，写一下，加深记忆。

// 懒汉模式 用的时候再实例化
class SingleLazy {
    private static instance: SingleLazy = null;
    private constructor() { }

    public static getInstance() {
        if (!this.instance) {
            this.instance = new SingleLazy()
        }
        return this.instance
    }
}

const instance1 = SingleLazy.getInstance()
console.log('instance1 :>> ', instance1);


// 饿汉模式 饿的迫不及待了，代码执行时就创建
class SingleHungry {
    private static instance: SingleHungry = new SingleHungry()
    private constructor() { }
    public static getInstance() {
        return this.instance
    }
}

const instance2 = SingleHungry.getInstance()
console.log('instance2 :>>', instance2)


// 多例模式，同时创建多个实例，轮流着用
class Multi {
    private static maxInstance = 3; // 最多三个实例
    private static instanceList: Array<Multi> = ((): Array<Multi> => {
        let arr = []
        for (let i = 0; i < this.maxInstance; i++) {
            arr.push(new Multi())
        }
        return arr
    })();

    private static point = 0; // 指向某个实例的指针
    private constructor() { }

    // 实例指针从0开始，不断移动
    public static getInstance() {
        let _p = this.point
        this.point = (this.point + 1) % this.maxInstance;
        return this.instanceList[_p]
    }
}

const singleMulti1 = Multi.getInstance();
const singleMulti2 = Multi.getInstance();
const singleMulti3 = Multi.getInstance();
const singleMulti4 = Multi.getInstance();

console.log('singleMulti1===singleMulti2 :>> ', singleMulti1 === singleMulti2);
console.log('singleMulti2===singleMulti3 :>> ', singleMulti2 === singleMulti3);
console.log('singleMulti1===singleMulti4 :>> ', singleMulti1 === singleMulti4) // 只有三个实例，所以最后一个1和4是同一个实例

首先避免使用者强行new实例，需要把构造函数私有化private constructor,然后再通过静态函数返回实例。

这里有个场景问题，单例模式不适用于类传参模式