对于并发调用返回false的简单锁-javascript

我想锁定同步执行的异步函数。函数只能由一个调用者执行，并且在执行之后，它应该作为输出得到true，而其他调用者作为返回得到false，而不执行函数的逻辑内容。其他人不应等待当前调用方完成

这就是我迄今为止所尝试的：

class Lock {
    constructor() {
        this.locked = false;
    }
    lock(resolve) {
        if (this.locked) {
            resolve(false)
        }
        this.locked = true
        return
    }
    release(resolve) {
        this.locked = false;
        resolve(true)
    }


}

let lock = new Lock();

function myFunction() {
    return new Promise(resolve => {
        lock.lock(resolve);
        //do something - this takes time includes some api calls and db operations
        lock.release(resolve);
    })
}

async function callSite() {
    const executed = await myFunction();
    if(executed){
        //do something
    }
    else{
        //do another thing
    }
}

---

但它似乎并没有像预期的那样起作用。有人能帮我改进一下吗？

承诺执行并不总是保证在解决或拒绝后立即停止；在检查锁并退出或继续相应的承诺后，必须返回一个布尔值

运行下面的代码段；这是一个例子，有3个按钮，具有相同的承诺和3秒的延迟。当一个按钮运行时，所有其他按钮都无法执行

类锁{
构造函数（）{
this.locked=false；
}
锁定（解析）{
如果（此项已锁定）{
决议（假）；
返回false；
}
this.locked=true
返回true；
}
释放（解决）{
this.locked=false；
解析（真）
}
}
let lock=新锁（）；
函数myFunction（{resultEl}）{
resultEl.textContent=“正在运行”；
返回新承诺（解决=>{
//检查它是否锁上了
如果（！lock.lock（解析））{
//如果是，则返回并退出该函数，即使承诺已解决
返回；
}
//做点什么-这需要时间，包括一些api调用和db操作
//只需等待3秒钟，即可卸下离心力
设置超时（（）=>{
锁定、释放（解析）；
}, 3000);
})
}
异步函数callSite（）{
this.disabled=true；
const executed=wait myFunction（{resultEl:this.nextSibling}）；
this.disabled=false；
如果（已执行）{
this.nextSibling.textContent=`在${（新日期）.getTime（）完成`；
}
否则{
this.nextSibling.textContent=`未在${（新日期）.getTime（）}`执行；
}
}
document.getElementById（'a-button'）。addEventListener（'click'，callSite）；
document.getElementById（'b按钮'）。addEventListener（'click'，callSite）；
document.getElementById（'c按钮'）。addEventListener（'click'，callSite）
div{
边缘底部：10px；
}
钮扣{
右边距：5px；
}

经营
跑B
运行C
您期望得到什么，实际发生了什么？当我快速调用此调用站点函数时，它总是返回true。为了进行测试，我在lock.lock之后使用了fetch函数，然后使用（lock.release）。它应该在存在未完成的fetch时丢弃调用。Try
const executed=myFunction（）
-删除
等待
另外，在
锁定
类方法中，替换最后一个命令
返回带有
解析（true）