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之前的版本,该方案可行。

你可能感兴趣的:(node.js 如何保证数据一致性)