我对node的异步编程有一点点了解，不知道问的问题是否有价值，如果没什么价值，多包涵。 我知道node是单线程event loop的，没有抢占式“线程”，也就不存在一些memory race condition。 但如果出现逻辑上的race condition该怎么做？
当然即使需要lock，也不是多线程、多进程里面的锁，好像不需要os提供的原子操作？
我能想到下边这个例子。 例子比较简陋，只是想说明如果一次request handle需要 read和write各一次io，而且不希望read和write两次操作之间有数据被修改。 我在stackoverflow上搜类似的问题，有人提问，但是回答者寥寥。有回答提到AsyncLock这个库，我看到github上这个库，star很少，我试了一下这个库应该能满足一些要求。
下边这段代码print出来结果都是1（也就是hit没有被正确地自增）。
// Fake_Database is a fake database (or some other I/O)
class Fake_Database {
constructor() {
this._hit = 0;
}
// 异步做获取hit变量，类比从数据库中读
async get_hit() {
return this._hit;
}
// async set hit
// 异步写hit，类比向数据库中写
async set_hit(hit) {
this._hit = hit;
}
}
const service_fake_database = new Fake_Database();
// fake http handler
// 期望：每次有人访问handler1，hit++
async function handler1(req, res) {
const hit_old = await service_fake_database.get_hit();
const hit_new = hit_old + 1;
await service_fake_database.set_hit(hit_new);
res.success = true;
res.hit = hit_new;
}
// client A 和 client B 并发地 call `handler1(req,res)`，就有可能出现交错
// [A get hit] -> [B get hit] -> [A set hit] -> [B set hit]
// 两次handler1 call，但hit只会+1一次。
// 在内存层面上没有竞争，但是逻辑上有竞争
// 我知道数据库应该会有 原子自增
// 我只是想举个例子，假如出现某种情况一定要将读和写（2次io）分离呢？
// 但又不希望有其他“线程”（就是指 一个执行顺序，不是传统意义上的线程）在读和写之间 修改数据
// 比如我写的代码里的先读后写
let count = 0;
async function send_req() {
const req = {}, res = {};
await handler1(req, res);
console.log(`req${count++} -- ${res.hit}`);
}
async function main() {
for(let i=0;i<1000;i++){
send_req();
}
}
main();
特地注册了账号来回答这个问题，题主所描述的并不是多线程，只是异步逻辑的执行顺序，题中的代码是直接用了es7新特性async/await写的，不知道题主是否了解其原理，async/await其实只是promise的语法糖，在函数中其实是一个接一个then下去的，而promise的嵌套执行顺序就涉及到了js的事件循环机制（宏事件，微事件，面试常考）（注意node和浏览器环境有细微差别）。上面这些代码始终输出1是必然的，因为所有的get必然先于set，所以这里根本不需要lock（终于回到正题了），而由于线程竞争导致的结果应该是不确定的，这也反证了并不需要题主所说的lock机制. 留个邮箱求职，杭州滨江前端/node岗 2.5年 [email protected]
async function main() {
for(let i=0;i<1000;i++){
await send_req();
}
}
少了个await！循环中没有await，导致所有循环一次性进入异步队列；await是顺序执行，遇到await就丢队列（其向下的代码一并丢），所以await service_fake_database.get_hit() 一次全部进队列，获取的全是0，之后的同理。
题外话：您这么做的想法是不是：类似后端实现session认证；如果是这样子的话，可以参照一下express的session中间件的做法
@LeavesSky 我特意没有加await，因为main函数是在模拟有很多client（1000个）几乎同时向server发请求，就是说main 是client的行为，handler1应该可以处理这种情况才行（没有await的情况）
@atian25 如果我只是想在自己的进程里，在代码里限制一下执行顺序，如果涉及到分布式锁，还需要进程之间通信，甚至多个机器通信，overhead有点大，而且感觉稍微有点杀鸡用牛刀。还有，能在语言层面实现互斥肯定是最好的，不用引入过多的依赖。
@Dodd2013 我知道这段代码去掉async await语法糖之后，用promise的写法，也知道这段代码输出结果必然都是1。（我问题描述里有点没说清楚，可能会让人理解成我在问这段代码为什么能达到串行自增的目的） 我希望找到一种handler1的写法，能正确处理同时很多client的hit++。
这段代码里所有的set在eventloop都排在任何一个get后边（就是说 执行顺序是 client1 get, client2 get, client3 get, …, client1 set, client2 set, client3 set …） 但我想做的事情就是重拍 get和set的顺序，变成 client1 get set, client2 get set, client3 get set这样的串行。
单机单线程的话，我有个思路就是自己维护一个事件队列，将一次req的get，set打包，要不然就是锁了，因为第二次的get必须在第一次的set后，而第二次get时如果需要知道第一次req完成了没有，这就必须做一些额外的事情了
@Dodd2013 将get和set打包，这就有点广义的“锁”的意思了，理论上get和set是两次io操作。比如下边这个做法就是用AsyncLock把一次req的get和set打包了。
const AsyncLock = require('async-lock');
const lock = new AsyncLock();
// Fake_Database is a fake database (or some other I/O)
class Fake_Database {
constructor() {
this._hit = 0;
}
// async get hit count of website
async get_hit() {
return this._hit;
}
// async set hit
async set_hit(hit) {
this._hit = hit;
}
}
const service_fake_database = new Fake_Database();
// fake http handler
async function handler1(req, res) {
await lock.acquire('hit', async function (done) {
const hit_old = await service_fake_database.get_hit();
const hit_new = hit_old + 1;
await service_fake_database.set_hit(hit_new);
res.success = true;
res.hit = hit_new;
done();
})
}
// client A and client B call `handler1` concurrently, and overlaps each other
// A[get hit] -> B[get hit] -> A[set hit] -> B[set hit]
// only one hit is counted while 2 clients visited handler
// There is no race condition in memory, but race in logic.
// I know that we can increment hit atomically inside database.
// What if we face some case that we must separate it to 2 I/Os?
// First read and then write, or some more complicated actions.
let count = 0;
async function send_req() {
const req = {}, res = {};
await handler1(req, res);
// const hit = await service_fake_database.get_hit();
console.log(`req${count++} -- ${res.hit}`);
}
async function main() {
console.time("hit_time");
await Promise.all(Array.from(new Array(1000)).map(x => send_req()))
console.timeEnd("hit_time");
}
main();
@Dodd2013 “要不然就是锁了” 这句话是指node里面最好不出现锁吗？但感觉这种情况避免不了广义的“锁”的存在。广义的“锁”是指在代码块里有互斥、保护critial area的作用，但不一定是多线程模型里面由kernel提供的开销比较大的锁（比如锁内存，和上古单核时代关闭时钟中断之类的）。
我这个做法和楼主的 asynclock 一个道理… 这种情况避免不了 “锁” 吧
function getHandler(){
let waitLock = Promise.resolve();
return async function handler1(req, res) {
let lastLock = waitLock;
let next;
waitLock = new Promise(r=>(next = r));
await lastLock;
try{
const hit_old = await service_fake_database.get_hit();
const hit_new = hit_old + 1;
await service_fake_database.set_hit(hit_new);
res.success = true;
res.hit = hit_new;
}catch(e){
console.error(e);
}finally{
next();
}
}
}
const handler1 = getHandler()
上面的代码就能实现锁了. (然而我觉得我上面的代码有内存泄露问题…)
@abiuDoIT 我对于异步编程仅仅算个票友，比较好奇，nodejs写server的时候，会遇到我说的这种需要“锁”的情况吗？遇到了会通过什么办法绕过吗？
