typescipt协程锁

协程锁是什么

在线程中有线程锁这个概念，是为了保护对一个变量的写操作导致的线程处理结果不一致问题，同样的，协程锁也是这个概念，

怎么实现

对于ts，并没有直接可用的协程锁可用，但是根据其原理可以很轻松地写出来，

export class CoroutineLock{
    private _lock:boolean = false;
    private _waitList:Array<Function> = [];

    public async lock(){
        if(this._lock){
            await new Promise((resolve) => {
                this._waitList.push(resolve);
            });
        }
        this._lock = true;
    }

    public unlock(){
        this._lock = false;
        if(this._waitList.length > 0){
            let resolve = this._waitList.shift();
            resolve && resolve();
        }
    }
}

以上即为协程锁的实现，

例子

class Context{
	arr:number[] = null;

	async init(){
		this.arr = [];
		//其他操作...
	}

	test(){
		console.log(this.arr[0]);
	}
}

let isInit = false;
const context = new Context():

function async caculator(){
	if(!isInit){
		isInit = true;
		//初始化上下文
		await context.init();
	}
	
	context.test():
}

for(int i = 0; i < 10; i++){
	caculator();
}

以上直接开启10个协程，初始化在这个协程里面来做，我这样写可能有一些不合理，但是真正写需求的时候碰到的问题可能是各种各样的，以上只是一个例子，有9个协程会运行到没有初始化的context.text()函数中，此时因为上下文还没有初始化完毕，直接就会崩溃，以下为改造，

class Context{
	arr:number[] = null;

	async init(){
		this.arr = [];
		//其他操作...
	}

	test(){
		console.log(this.arr[0]);
	}
}

let isInit = false;
const context = new Context():
const coroutineLock = new CoroutineLock();

function async caculator(){
	await coroutineLock.lock();
	if(!isInit){
		isInit = true;
		//初始化上下文
		await context.init();
	}
	coroutineLock.unlock();
	
	context.test():
}

for(int i = 0; i < 10; i++){
	caculator();
}

如上所示，只是在初始化的时候进行加锁，当其中一个协程进入初始化的时候，其他9个协程将会在试图获得锁的时候直接睡眠，当初始化完毕后，调用了unlock的时候将会唤醒一个协程从lock出苏醒继续执行，并且当这个唤醒的协程执行到unlock的时候它又会继续唤醒下一个协程，最终10个协程都会正确执行，

结束语

以上的例子我都觉得举得不是很合理，但是总会碰见类似的场景的，到时候就不就是考虑的这一点了，希望能对你有所帮助，