Implementation Mutex based on Promise logic in TypeScript

async-mutext.ts

class AsyncMutex {
    private _locked = false;
    private _waiting: (() => void)[] = [];

    constructor() {
        this._unlock = this._unlock.bind(this);
    }

    async lock(): Promise<() => void> {
        if (!this._locked) {
            this._locked = true;
            return this._unlock;
        } else {
            this._locked = true;
            return new Promise<() => void>(resolve => {
                this._waiting.push(() => resolve(this._unlock));
            });
        }
    }

    private _unlock() {
        if (this._waiting.length > 0) {
            const next = this._waiting.shift();
            next!();
        }

        if (this._waiting.length === 0) this._locked = false;
    }
}

const mutex = new AsyncMutex();

async function criticalSection(id: number) {
    const unlock = await mutex.lock();
    try {
        console.log(`Task ${id} entered critical section`);
        await new Promise(r => setTimeout(r, 1000)); // имитация async-работы
        console.log(`Task ${id} leaving critical section`);
    } finally {
        unlock(); // обязательно освобождаем
    }
}

const main = async () => {
    for (let i = 1; i <= 3; i++) {
        criticalSection(i);
    }
    await new Promise(r => setTimeout(r, 5 * 1000)); // имитация async-работы
    for (let i = 10; i <= 13; i++) {
        criticalSection(i);
    }
    for (let i = 20; i <= 23; i++) {
        criticalSection(i);
    }
};

main();