node.js 代码会导致竞争条件吗？

Question

根据我的阅读，当不同的线程尝试更改共享变量时会出现竞争条件，这可能导致这些线程的任何串行执行顺序都不可能出现的值。

但是 node.js 中的代码在单线程中运行，那么，这是否意味着用 node.js 编写的代码没有竞争条件？

Answer 1

没有。 Node.js 没有由上下文切换引起的竞争条件；但是，您仍然可以编写一个 node.js 程序，其中以意外顺序发生的异步事件会导致状态不一致。

例如，假设您有两个函数。第一个通过 WebSocket 发送消息，并在回调中保存回复。第二个函数删除所有已保存的回复。按顺序调用函数并不能保证消息列表为空。在进行异步编程时，考虑所有可能的事件顺序很重要。

编辑：这是一些示例代码

var messages = [];

...

io.sockets.on('connection', function (socket) {
    socket.emit('ask', { question: 'How many fish do you have?' });
    socket.on('reply', function (data) {
        messages.push(data);
    });
    ...
    wipe();
});

function wipe() {
    setTimeout(function() {
        messages = [];
    }, 500);
}

Answer 2

竞争条件仍然可能发生，因为它们实际上与线程无关，但在对事件时间和顺序做出假设时，线程只是其中的一个示例。

Node.js 是单线程的，但仍然是并发的，并且可能出现竞争条件。例如：

var http = require('http');

var size;

http.createServer(function (req, res) {
  size = 0;

  req.on('data', function (data) {
    size += data.length;
  });

  req.on('end', function () {
    res.end(size.toString());
  })

}).listen(1337, '127.0.0.1');

这个程序应该向客户发送他们请求的大小。如果您对其进行测试，似乎可以正常工作。但它实际上是基于隐含的假设，即请求开始和结束事件之间没有发生任何事情。如果有 2 个或更多并发客户端，它将无法工作。

这里发生这种情况是因为size 变量是共享的，很像两个线程共享一个变量时。您可以考虑一个抽象的“异步上下文”，它很像线程，但它只能在某些点暂停。

Answer 3

没有。确实，您不能在单线程、非 I/O 执行程序上出现竞争条件。

但是 node.js 的速度主要是因为它的非阻塞编程方式。非阻塞意味着设置一个响应事件的监听器，你可以在等待这个响应的同时做一些别的事情。

为什么？ 因为获取响应的工作是在另一个线程上完成的。 数据库，文件系统，在另一个线程上运行，客户端显然在另一台计算机上运行，​​您的程序工作流可以依赖 它的回应。

严格来说，node.js 在一个线程上运行，但您的程序工作流程，包括 I/O（数据库、文件系统）、客户端和所有内容，都在多个线程上运行。

因此，如果您请求将某些内容添加到数据库中，然后只发送删除请求而不等待第一个请求的响应，那么仍然可能存在竞争条件。 如果数据库与 node.js 在同一个线程中运行，则不会出现竞争条件，并且请求只是立即执行的函数调用。

Answer 4

是的。一旦您开始共享资源，Node.js 就会遇到竞争条件。

我还错误地认为您无法在 Node.js 中获得竞争条件，因为它是单线程性质的，但是一旦您使用节点外部的共享资源（例如来自文件系统的文件），您就可以进入比赛条件。当我试图理解这一点时，我在这个问题中发布了一个关于这个问题的例子：node.js readfile woes

Node.js 与其他环境的不同之处在于您有一个 JavaScript 执行线程，因此只有一个 JavaScript 实例在运行您的代码（这与有许多线程执行您的应用程序代码的线程环境相反同时。）

Answer 5

是的。可以的。

当您使用cluster 模块初始化多个工作器时，Nodejs 中的竞争条件是可行的。

案例

var cluster = require('cluster');
var fs = require('fs');
if(cluster.isMaster){
    for(var i=0;i<4;i++){
        cluster.fork();
    }
}else{
    fs.watch('/path/to/file',function(){
        var anotherFile = '/path/to/anotherFile';
        fs.readFile(anotherFile,function(er,data){
             if(er){
                 throw er;
             }
             data = +data+1;
             fs.writeFile(anotherFile,data,function(er){
                 if(er){
                     throw er;
                 }
                 fs.readFile(anotherFile,function(er,newData){
                     if(er){
                         throw er;
                     }
                     console.log(newData); //newData is now undetermined
                 });
             });
        });
    });
}

每当您更改监视文件时，4 个工作人员将同时执行处理程序。此行为会导致未确定的newData。

解决办法

if(cluster.isMaster){
    var lock = {};
    var timer = setInterval(function(){
        if(Object.keys(cluster.workers).length >= 4){
            return clearInterval(timer);
        }
        //note that this lock won't 100% work if workers are forked at the same time with loop.
        cluster.fork().on('message',function(id){
             var isLocked = lock[id];
             if(isLocked){
                 return console.log('This task has already been handled');
             }
             lock[id] = 1;
             this.send('No one has done it yet');
        });
    },100);
}else{
     process.on('message',function(){
        //only one worker can execute this task
        fs.watch('/path/to/file',function(){
            var anotherFile = '/path/to/anotherFile';
            fs.readFile(anotherFile,function(er,data){
                 if(er){
                     throw er;
                 }
                 data = +data+1;
                 fs.writeFile(anotherFile,data,function(er){
                     if(er){
                        throw er;
                     }
                     fs.readFile(anotherFile,function(er,newData){
                         if(er){
                             throw er;
                         }
                         console.log(newData); //newData is now determined
                     });
                 });
            });
        });
     });
     //ask the master for permission
     process.send('watch');
}

Answer 6

是的，竞争条件（在共享资源的意义上由于事件的顺序而具有不一致的值）仍然可能发生在任何有可能导致其他代码运行的暂停点的地方（在任何行处都有线程），以这段完全是单线程的异步代码为例：

var accountBalance = 0;

async function getAccountBalance() {
    // Suppose this was asynchronously from a database or something
    return accountBalance;
};

async function setAccountBalance(value) {
    // Suppose this was asynchronously from a database or something
    accountBalance = value;
};

async function increment(value, incr) {
    return value + incr;
};

async function add$50() {
    var balance, newBalance;
    balance = await getAccountBalance();
    newBalance = await increment(balance, 50);
    await setAccountBalance(newBalance);
};

async function main() {
    var transaction1, transaction2;
    transaction1 = add$50();
    transaction2 = add$50();
    await transaction1;
    await transaction2;
    console.log('$' + await getAccountBalance());
    // Can print either $50 or $100
    // which it prints is dependent on what order
    // things arrived on the message queue, for this very simple
    // dummy implementation it actually prints $50 because
    // all values are added to the message queue immediately
    // so it actually alternates between the two async functions
};

main();

此代码在每个等待处都有暂停点，因此可能会在错误的时间在两个函数之间进行上下文切换，产生“$50”而不是预期的“$100”，这与维基百科的竞赛条件示例基本相同在线程中，但有明确的暂停/重新进入点。

就像线程一样，尽管您可以使用锁（又名互斥锁）之类的东西来解决此类竞争条件。所以我们可以像线程一样防止上述竞争条件：

var accountBalance = 0;

class Lock {
    constructor() {
        this._locked = false;
        this._waiting = [];
    }

    lock() {
        var unlock = () => {
            var nextResolve;
            if (this._waiting.length > 0) {
                nextResolve = this._waiting.pop(0);
                nextResolve(unlock);
            } else {
                this._locked = false;
            }
        };
        if (this._locked) {
            return new Promise((resolve) => {
                this._waiting.push(resolve);
            });
        } else {
            this._locked = true;
            return new Promise((resolve) => {
                resolve(unlock);
            });
        }
    }
}

var account = new Lock();

 async function getAccountBalance() {
    // Suppose this was asynchronously from a database or something
    return accountBalance;
};

async function setAccountBalance(value) {
    // Suppose this was asynchronously from a database or something
    accountBalance = value;
};

async function increment(value, incr) {
    return value + incr;
};

async function add$50() {
    var unlock, balance, newBalance;

    unlock = await account.lock();

    balance = await getAccountBalance();
    newBalance = await increment(balance, 50);
    await setAccountBalance(newBalance);

    await unlock();
};

async function main() {
    var transaction1, transaction2;
    transaction1 = add$50();
    transaction2 = add$50();
    await transaction1;
    await transaction2;
    console.log('$' + await getAccountBalance()); // Now will always be $100 regardless
};

main();