Kann node.js code Ergebnis in race conditions?

Nicht. Das stimmt man kann keine race condition bei der ein einzelnes Gewinde, nicht I/O zu tun Programm.

Aber node.js ist vor allem schnell wegen seiner non-blocking Art der Programmierung. Non-blocking bedeutet, dass die Erstellung eines Hörer zu einer Reaktion Veranstaltung, können Sie etwas anderes tun, während warten diese Antwort.

Warum ? Weil die Arbeit immer die Antwort erfolgt in einem anderen thread. Datenbank, Dateisystem, die Ausführung auf anderen thread, client offensichtlich läuft auf einem anderen computer, und Sie das Programm workflow abhängen kann
seine Antwort.

So streng genommen node.js läuft in einem thread, aber Ihre workflow-Programm, die include-I/O (Datenbank, filesystem), client und alles läuft auf vielen thread.

Also es kann immer noch sein race-Bedingung, wenn Sie eine Anfrage, um etwas hinzufügen zu einer Datenbank, dann senden Sie einfach eine Anfrage zu löschen, ohne warten auf die Antwort der ersten Anfrage. Würde es auch keine race-condition, wenn die Datenbank läuft im gleichen thread wie node.js und die Anfrage war nur ein Funktionsaufruf ausgeführt sofort.

InformationsquelleAutor der Antwort Guilro

Jarace-Bedingungen (im Sinne einer freigegebenen Ressource mit einem inkonsistenten Wert aufgrund der Reihenfolge der Ereignisse) kann immer noch passieren überall, es gibt einen Punkt der Aussetzung dazu führen könnte, dass andere code ausgeführt (mit Fäden, die am jede Zeile), nehmen Sie zum Beispiel dieses Stück von asynchronem code ist komplett single-threaded:

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();

Dieser code-Punkte-Aufhängung bei jedem einzelnen erwarten und als solche könnte context-switch zwischen den beiden Funktionen auf eine schlechte Zeit zu produzieren "$50" anstatt des erwarteten "$100", dies ist im wesentlichen das gleiche Beispiel wie Wikipedia-Beispiel für Race Conditions in threads, die aber mit expliziten Punkten der Aufhängung/re-entry.

Genau wie threads, aber lösen können Sie solche race conditions mit Dingen wie einem Schloss (aka mutex). So konnten wir verhindern, dass die oben genannten race-Bedingung in der gleichen Weise wie threads:

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();

InformationsquelleAutor der Antwort Jamesernator

Race conditions können immer noch vorkommen, als Sie wirklich haben nichts zu tun mit threads, sondern auf Annahmen über event-timing und die Reihenfolge, so threads sind nur ein Beispiel.

Node.js ist single-threaded, aber immer noch gleichzeitig, und race conditions) sind möglich. Zum Beispiel:

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');

Diesem Programm senden soll, Kunden eine Größe, die Ihrer Anfrage. Wenn Sie es testen, werden offenbar korrekt funktioniert. Aber es ist eigentlich basiert auf der impliziten Annahme, dass nichts passiert zwischen request start-und end-Ereignisse. Wenn es 2 oder mehr clients gleichzeitig, es wird nicht funktionieren.

Dies geschieht hier, weil size variable geteilt wird, wie eine Menge, wenn zwei threads teilen sich eine variable. Können Sie denken über einen abstrakten "asynchrnous Kontext", das ist ein viel wie Faden, aber es kann nur ausgesetzt werden, an bestimmten stellen.

InformationsquelleAutor der Antwort vkurchatkin