node.js 如何保证数据一致性

首先声明，本人不是做后台的，下面结论可能不是最佳方案, 有知道的麻烦指点下。

背景：项目中用的一个node.js框架parse-server写的后台接口，接口实现如下

        let query = new Parse.Query('Test');
        query.equalTo('objectId', id);
        let t = await query.first({ useMasterKey: true });
        let age = t.get('age');
        if (age > 0) {
            t.set('age', age - 1);
            await t.save(null, { useMasterKey: true });
        }

当有多个客户端同时调用到该方法时，如何保证age数据准确性？

虽然node是单线程的，但是由于代码中存在异步操作，当多个用户同时调用接口时，对age的修改可能并不是希望的结果，会导致数据错乱。
举个例子，命名上述方法为F，有 A、B两个客户端同时调用方法F，A客户端调用F当执行到异步方法await时，资源会调度执行到B客户端的F方法也执行await，此时两边查询到的age是相同值，各自对age进行操作后结果就只减去了1而不是希望的2，数据错乱。
需要注意的是，如果该接口中没有异步操作，由于node是单线程的，那么就不会出现上述问题。

解决方案：
模仿锁的原理写了个Lock类，对需要保证数据一致性的地方进行加锁即可。

const locks = {};
class Lock {

    constructor(id) {
        if (id === undefined || id == null) throw 'id can not been empty'
        this.id = id;
        if (locks[id] === undefined) locks[id] = false
    }

    delay(time) {
        return new Promise(reslove => setTimeout(reslove, time))
    }

    async lock() {
        if (locks[this.id]) {
            for (let index = 0; index < 100000000000; index++) {
                await this.delay(10);
                if (!locks[this.id]) break;
            }
        }
        locks[this.id] = true;
    }

    unlock() {
        locks[this.id] = false;
    }
}

module.exports = Lock;

原理：由于node是单线程，全局变量locks的访问是同步的。
举例：A、B客户端同时调用上面的方法，假设A先进入方法体，A创建锁，加锁，赋值locks[id]=true，执行try中的代码，里面有异步操作，由于并发性，node将线程资源调度给客户端B，B进入方法体。await lock.lock()执行时发现locks[id]为true，进入for循环等待，直到锁释放才进入try代码，保证try里面代码依次执行。
这是模仿锁的原理写的一份代码，由于当锁释放时其他资源可能还需要等待10ms，性能没有达到最大化，但是一般情况也够用了。

以下是使用方式

    let lock = new Lock(id);
    await lock.lock();
    try {
        let query = new Parse.Query('Test');
        query.equalTo('objectId', id);
        let t = await query.first({ useMasterKey: true });
        let age = t.get('age');
        if (age > 0) {
            t.set('age', age - 1);
            await t.save(null, { useMasterKey: true });
        }
    } catch (error) {
        throw error
    } finally {
        lock.unlock();
    }

接下来是第二种方案

const AsyncLocks = {};  // {key:[], key2:[], ...}
class AsyncLock {

    static lock(key, fn) {

        if (AsyncLocks[key] == undefined) {
            AsyncLocks[key] = [fn];
        } else {
            AsyncLocks[key].push(fn);
            return;
        }

        let exec = () => {
            let firstFn = AsyncLocks[key].shift()
            let callback = () => AsyncLocks[key].length ? exec() : delete AsyncLocks[key]
            firstFn(callback);
        }

        exec();
    }
}

使用方法

 AsyncLock.lock(key, async (completeCallback) => {
        try {
           ... 需要同步的代码
        } catch (error) {
           // parse 3.0开始，Cloud方法不再使用response.success和response.error的方式回调，错误信息无法回传给客户端
            throw error   
        } finally {
            completeCallback();   // 重要，一定要执行
        }
    })

利用队列，将后续的方法传入数组中顺序执行。该方案效率高
举例： A、B两个客户端同时执行到了F方法，A进入方法并开始执行，当node遇到异步任务时将资源调度给B客户端，B发现AsyncLocks[key]数组中有值则将对应的回调方法添加到数组中并释放资源，A异步任务完成后发现数组中还有值(B的回调函数)，执行B的回调函数。
从例子中可以看出，由于B提前结束释放了资源，B客户端是拿不到回调函数的返回值，错误信息等的。由于这个原因，该方案大多情况并不适用。但是如果接口函数支持回调的方式回传错误信息，如parse Cloud 3.0之前的版本，该方案可行。

最后编辑于：2020.09.28 17:05:17