Synchron und asynchron

Einführung

Während sich Webanwendungen weiterentwickeln, entwickelt sich auch JavaScript als weit verbreitete Programmiersprache ständig weiter. In der Web-Front-End-Entwicklung wird JavaScript hauptsächlich für die Browser-UI-Verarbeitung verwendet. Die UI-Entwicklung ist ein typisches ereignisgesteuertes Single-Threaded-Modell, sodass JavaScript auch ein Programmierparadigma mit asynchroner Verarbeitung als Hauptprogrammierparadigma gebildet hat. Bei großen und komplexen Anwendungen werden jedoch die durch die asynchrone Programmierung verursachten Probleme und die Komplexität immer offensichtlicher.

Das Aufkommen von Node.js bringt ein neues asynchrones Programmierparadigma in JavaScript mit sich: Ereignisschleifen und Rückruffunktionen. Dieses Programmierparadigma ist effizient und prägnant und eignet sich für Szenarien mit hoher Parallelität und E/A-intensiver Nutzung. Dieses Programmierparadigma bringt jedoch auch seine eigenen Probleme und Komplexitäten mit sich. Insbesondere in großen und komplexen Anwendungen müssen sich Programmierer mit dem Problem der Verschachtelung vieler Rückruffunktionen und dem Problem der asynchronen Aufrufreihenfolge befassen, was die Komplexität erhöht und Schwierigkeitsgrad des Programms.

Um diese Probleme und Schwierigkeiten zu lösen, wurden fibjs ins Leben gerufen. fibjs ist ein Anwendungsserver-Entwicklungsframework, das hauptsächlich für die Web-Back-End-Entwicklung entwickelt wurde. Es basiert auf der Google v8-JavaScript-Engine und wählt eine andere Parallelitätslösung als der herkömmliche Rückruf. fibjs verwendet Glasfaser, um die durch asynchrone Aufrufe verursachte Geschäftskomplexität auf der Framework-Ebene zu isolieren, wodurch die Entwicklungsschwierigkeiten erheblich verringert und Leistungsprobleme durch häufige asynchrone Verarbeitung im Benutzerbereich verringert werden. Gleichzeitig bietet das synchrone Programmierparadigma im Vergleich zum herkömmlichen asynchronen Programmierparadigma die Vorteile einer besseren Lesbarkeit, einfacher Logik und einfacher Wartung.

Im folgenden Inhalt stellen wir die Vorteile und Funktionen von fibjs vor und erklären anhand von Beispielen, wie seine synchronen und asynchronen Programmierlösungen verwendet werden.

Fasereinführung

fibjs ist ein leistungsstarkes JavaScript-Server-Framework basierend auf der v8-Engine, hauptsächlich für die Web-Back-End-Entwicklung. Es wurde 2009 gestartet, weist bereits eine hohe Stabilität und Produktivität auf und verfügt über ein breites Anwendungsspektrum im In- und Ausland.

In fibjs wird Fiber verwendet, um das Problem zwischen Geschäftslogik und E/A-Verarbeitung zu lösen. Fiber unterscheidet sich von herkömmlichen Konzepten wie Threads, Coroutinen und Prozessen. Es handelt sich um einen leichtgewichtigen Thread auf Benutzerebene, der als kooperativer Multitasking-Mechanismus betrachtet werden kann. Fiber kann Geschäftslogik und E/A-Vorgänge in verschiedenen Kontexten ausführen und verwaltet Ressourcen intern durch Vorabzuweisung und Recycling. Im Vergleich zu herkömmlichen Threads und Prozessen ist es leichter, flexibler und effizienter.

Im Vergleich zu anderen Thread-Bibliotheken (wie pthread, WinThread, Boost.Thread usw.) bietet Fiber die folgenden Vorteile:

• Kollaborative Planung : Fiber ist eine kollaborative Planung, die keine präventive Planung durch den Kernel oder das Betriebssystem erfordert. Sie reduziert häufige Kontextwechsel, beschleunigt die Ausführungsgeschwindigkeit des Programms und vermeidet Konkurrenzbedingungen und Deadlock-Probleme zwischen Threads.

• Leicht : Jede Faser verbraucht nur wenig Stapelplatz, und in mehreren gleichzeitigen Anwendungen kann eine große Anzahl von Fasern erstellt werden, ohne dass das Problem entsteht, dass zu viel Speicher belegt wird.

• Effizienz : Fiber wird basierend auf den Eigenschaften der JavaScript-Sprache selbst implementiert und nutzt die überlegene Leistung der v8-Engine voll aus, die schneller ist als herkömmliche Thread-Bibliotheken.

Durch die Verwendung von Glasfaser können FIBJS die Geschäftslogik und die E/A-Verarbeitung trennen und so asynchrone Aufrufe in synchrone Aufrufe kapseln, wodurch das Schreiben und Verwalten von Code einfacher und leichter lesbar wird und gleichzeitig die Vorteile voll ausgeschöpft werden JavaScript-Sprache.

Synchrone Programmierung in fibjs

Bei der asynchronen Programmierung kann die Verschachtelung von Rückruffunktionen zu einer schlechten Lesbarkeit des Codes führen, leicht das Problem der Rückrufhölle verursachen und die Schwierigkeit des Codes sowie die Kosten für das Debuggen erhöhen. Das synchrone Programmierparadigma entspricht eher den menschlichen Denkmustern und macht die Codestruktur klarer, leichter lesbar und einfacher zu warten, was die Entwicklungseffizienz und Codequalität erheblich verbessern kann.

In fibjs ist die synchrone Programmierung ein sehr beliebtes und häufig verwendetes Programmierparadigma, das die Struktur und Logik des Codes intuitiver, einfacher zu verstehen und zu warten macht. Einige synchrone Programmierfunktionen und -module werden in fibjs stark unterstützt, z. B. util.sync, fs.readSync usw.

In fibjs können Sie asynchrone Funktionen integrierter Objekte direkt und synchron aufrufen:

1
2
3
4
const fs = require("fs");

const data = fs.readFile("/path/to/file");
console.log(data);

Sie können die asynchrone Funktion auch über util.sync und try...catch umschließen, damit die Faser den Rückgabewert des asynchronen Aufrufs erhalten und so den Synchronisationseffekt erzielen kann, zum Beispiel:

1
2
3
4
5
6
7
8
9
10
11
12
13
// load module
const coroutine = require("coroutine");
const util = require("util");
const fs = require("fs");

// use util.sync to wrap fs.readFile
function readFile(path) {
  return util.sync(fs.readFile)(path);
}

// call the sync function
const data = readFile("myfile.txt");
console.log(data);

Im obigen Beispiel haben wir eine Funktion namens readFile definiert und util.sync verwendet, um die asynchrone Funktion fs.readFile in eine synchrone Funktion zu kapseln. Diese Funktion kann Daten über synchrone Aufrufe direkt zurückgeben. Diese synchrone Aufrufmethode ähnelt dem traditionellen JavaScript-Programmierparadigma. Der Unterschied besteht darin, dass in fibjs der Thread nicht blockiert wird, sondern der asynchrone Effekt durch Fiber erreicht wird.

So funktioniert util.sync

util.sync ist eine effiziente Wrapper-Funktion des Kernels. Der folgende JavaScript-Code kann ähnliche Funktionen erreichen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const coroutine = require("coroutine");

function sync(func) {
  return function _warp() {
    var ev = new coroutine.Event();
    var e, r;

    func.apply(this, [
      ...arguments,
      function (err, result) {
        e = err;
        r = result;
        ev.set();
      }
    ]);

    ev.wait();
    if (e)
      throw e;

    return r;
  }
}

Dieser Code definiert eine Tool-Funktionssynchronisierung zum Konvertieren einer asynchronen Rückruffunktion in eine synchrone Aufruffunktion. Es empfängt eine Funktion func und gibt eine neue Funktion _wrap zurück. Diese neue Funktion implementiert die Funktion, die ursprüngliche Funktion in einen synchronen Aufruf umzuwandeln. In der _wrap-Funktion wird zunächst ein neues Event-Objekt ev für die Thread-Planung und das Warten auf asynchrone Rückrufergebnisse erstellt. Verwenden Sie dann die Apply-Methode, um die ursprüngliche Funktion func mit den angegebenen Parametern und einer neuen Callback-Funktion als Parameter aufzurufen. Während des Aufrufvorgangs erfolgt ein asynchroner Rückruf, und die neue Rückruffunktion speichert die zurückgegebenen Ergebnisse in den Variablen e und r und aktiviert das Ereignisobjekt. Abschließend wird anhand der Variablen e entschieden, ob eine Ausnahme ausgelöst oder die Variable r zurückgegeben werden soll. Diese Funktion implementiert eine Lösung zum Konvertieren asynchroner Rückruffunktionen in synchrone Aufrufe, wodurch die Lesbarkeit und Wartbarkeit der Funktion verbessert werden kann.

Asynchrone Programmierung in fibjs

In fibjs können die meisten asynchronen Methoden (einschließlich E/A- und Netzwerkanforderungsmethoden usw.) sowohl synchrone als auch asynchrone Aufrufe unterstützen, sodass Entwickler jederzeit entsprechend ihren Programmieranforderungen auswählen können, welche Methode sie verwenden möchten.

Am Beispiel von fs.readFile() können wir diese Methode auf zwei Arten verwenden:

Asynchrone Methode: Verarbeiten Sie das Ergebnis des Lesens der Datei, indem Sie eine Rückruffunktion übergeben, zum Beispiel:

1
2
3
4
5
6
const fs = require("fs");

fs.readFile("/path/to/file", (err, data) => {
  if (err) throw err;
  console.log(data);
});

Diese Methode eignet sich für Situationen, in denen Sie nach dem Lesen der Datei einige Vorgänge ausführen müssen.

Synchrone Methode: Rufen Sie den Inhalt der Datei ab, indem Sie keine Rückruffunktion übergeben, zum Beispiel:

1
2
3
4
const fs = require("fs");

const data = fs.readFile("/path/to/file");
console.log(data);

In diesem Beispiel erhalten wir den Inhalt der Datei, indem wir die Rückgabewertdaten der Datei lesen. Es ist nicht erforderlich, zu warten, bis die Rückruffunktion das Lesen der Datei abgeschlossen hat, bevor wir mit dem Vorgang fortfahren. Diese Methode eignet sich für Situationen, in denen Sie einige Vorgänge ausführen müssen, bevor das Lesen der Datei abgeschlossen ist.

Es ist ersichtlich, dass diese Funktion der Unterstützung sowohl synchroner als auch asynchroner Aufrufe es Entwicklern ermöglicht, entsprechend ihren eigenen Anforderungen und Entwicklungsszenarien unterschiedliche Methoden zu verwenden. In einigen Fällen ist synchroner Code besser lesbar und einfacher zu warten und zu debuggen; in einigen Fällen kann asynchroner Code die Reaktionsgeschwindigkeit und Leistung des Codes besser verbessern.

Bei der Verwendung der Synchronisationsmethode ist jedoch Vorsicht geboten, da diese Methode in manchen Fällen die aktuelle Glasfaser blockieren kann. Daher müssen wir die geeignete Programmiermethode basierend auf den tatsächlichen Anforderungen auswählen.

abschließend

In diesem Artikel stellen wir den synchronen Programmierstil und die asynchronen Programmierlösungen von fibjs sowie deren Vorteile und Anwendungsszenarien vor. Wir haben erwähnt, dass Fibjs die betriebliche Komplexität reduzieren und die Effizienz der Codeentwicklung verbessern können, indem sie Glasfaser verwenden, um Geschäftslogik- und Leistungsprobleme zu isolieren, die durch asynchrone Verarbeitung verursacht werden. Gleichzeitig haben wir auch die Vorteile von fibjs bei der E/A-Verarbeitung und Speicherverwaltung hervorgehoben, was eine große Bequemlichkeit bei Entwicklung, Test und Wartung mit sich bringt.

Abschließend ermutigen wir die Leser, sich eingehend mit fibjs zu befassen und sich an fibjs-Beiträgen und Community-Aktivitäten zu beteiligen. Wir glauben, dass fibjs mit seiner leistungsstarken Leistung und Benutzerfreundlichkeit weiterhin die Aufmerksamkeit und Unterstützung der Open-Source-Community auf sich ziehen wird.

👉【Hot-Update des Servermoduls】