synchron und asynchron

Einführung

Da Webanwendungen weiter wachsen, wächst und entwickelt sich JavaScript, eine weit verbreitete Programmiersprache, weiter. In der Web-Front-End-Entwicklung wird JavaScript hauptsächlich für die UI-Verarbeitung von Browsern verwendet. Die UI-Entwicklung ist ein typisches Single-Threaded-Ereignis-gesteuertes Modell, daher hat JavaScript auch die asynchrone Verarbeitung als das Hauptprogrammierparadigma gebildet. Aber in großen und komplexen Anwendungen werden die Probleme und Komplexitäten, die durch die asynchrone Programmierung entstehen, immer offensichtlicher.

Das Aufkommen von Node.js brachte ein neues asynchrones Programmierparadigma in JavaScript: Ereignisschleifen und Callback-Funktionen. Dieses Programmierparadigma ist effizient und prägnant und eignet sich für Szenarien mit hoher Parallelität und E/A-intensiven Szenarien. Dieses Programmierparadigma bringt jedoch auch seine eigenen Probleme und Komplexitäten mit sich, insbesondere bei umfangreichen und komplexen Anwendungen müssen sich Programmierer mit der Verschachtelung vieler Callback-Funktionen und der Reihenfolge asynchroner Aufrufe auseinandersetzen, was die Komplexität und Schwierigkeit des Programms erhöht.

Um diese Probleme und Schwierigkeiten zu lösen, wurden Fibjs ins Leben gerufen. fibjs ist ein Anwendungsserver-Entwicklungsframework, das hauptsächlich für die Entwicklung von Web-Backends entwickelt wurde. Es basiert auf der JavaScript-Engine von Google v8 und wählt eine andere Concurrency-Lösung als den traditionellen Callback. fibjs verwendet Fiber, um die durch asynchrone Aufrufe verursachte Geschäftskomplexität auf der Framework-Ebene zu isolieren, wodurch die Entwicklungsschwierigkeiten erheblich reduziert und die Leistungsprobleme reduziert werden, die durch häufige asynchrone Verarbeitung im Benutzerbereich verursacht werden. Gleichzeitig ist das Paradigma der synchronen Programmierung im Vergleich zum traditionellen asynchronen Programmierparadigma lesbarer, einfacher in der Logik und leicht zu warten.

In den folgenden Inhalten stellen wir die Vorteile und Eigenschaften von fibjs vor und erklären anhand von Beispielen, wie man seine synchronen und asynchronen Programmierlösungen verwendet.

Faserprofil

fibjs ist ein hochleistungsfähiges JavaScript-Server-Framework basierend auf der v8-Engine, hauptsächlich für die Entwicklung von Web-Backends. 2009 gestartet, weist es bereits eine hohe Stabilität und Produktivität auf und verfügt über vielfältige Anwendungsfälle im In- und Ausland.

In fibjs wird Fiber verwendet, um das Problem zwischen Geschäftslogik und I/O-Verarbeitung zu lösen. Fibre 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 Ressourcen durch Vorabzuweisung und Recycling intern verwalten.Im Vergleich zu herkömmlichen Threads und Prozessen ist es leichter, flexibler und effizienter.

Gegenüber anderen Thread-Bibliotheken (wie pthread, WinThread, Boost.Thread etc.) hat Fiber folgende Vorteile:

• Kooperatives Scheduling : Fiber ist ein kooperatives Scheduling, das kein präemptives Scheduling durch den Kernel oder das Betriebssystem erfordert, wodurch häufige Kontextwechsel reduziert, die Ausführung des Programms beschleunigt und Wettlaufbedingungen und Deadlocks zwischen Threads vermieden werden.

• Geringes Gewicht : Jede Faser muss nur einen kleinen Stack-Platz beanspruchen, und eine große Anzahl von Fasern kann in Multi-Concurrent-Anwendungen erstellt werden, ohne eine übermäßige Speichernutzung zu verursachen.

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

Durch die Verwendung von Fiber können Fibjs die Geschäftslogik von der E/A-Verarbeitung trennen und dadurch asynchrone Aufrufe in synchrone Aufrufe kapseln, das Schreiben und Verwalten von Code einfacher und lesbarer machen und gleichzeitig die Vorteile der JavaScript-Sprache voll ausspielen.

Synchrone Programmierung in fibjs

Bei der asynchronen Programmierung kann die Lesbarkeit des Codes aufgrund der Verschachtelung von Callback-Funktionen schlecht sein, und es tritt wahrscheinlich das Problem der Callback-Hölle auf, was die Schwierigkeit des Codes und die Kosten für das Debugging erhöht. Das synchrone Programmierparadigma entspricht eher dem menschlichen Denkmodus, wodurch die Codestruktur klarer, leichter lesbar und einfacher zu warten ist, 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, wie z. B. util.sync, fs.readSync usw.

In fibjs können asynchrone Funktionen eingebauter Objekte direkt und synchron aufgerufen werden:

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 durch util.sync wickeln und versuchen ... zu fangen, damit die Faser den Rückgabewert des asynchronen Aufrufs erhalten kann, um beispielsweise einen synchronen Effekt zu erzielen:

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 definieren wir eine Funktion namens readFile und verwenden util.sync, um die asynchrone Funktion fs.readFile in eine synchrone Funktion zu kapseln.Diese Funktion kann Daten direkt über einen synchronen Aufruf zurückgeben. Diese synchrone Aufrufmethode ähnelt dem traditionellen JavaScript-Programmierparadigma, mit dem Unterschied, dass in fibjs Threads nicht blockiert werden, sondern asynchrone Effekte durch Fibers erzielt werden.

Das Prinzip von 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 Dienstprogrammfunktion sync zum Konvertieren einer asynchronen Rückruffunktion in eine synchrone Aufruffunktion. Es nimmt 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 zuerst ein neues Event-Objekt ev für die Thread-Planung erstellt und wartet auf asynchrone Callback-Ergebnisse. 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 Aufrufs erfolgt ein asynchroner Rückruf, und die neue Rückruffunktion speichert die zurückgegebenen Ergebnisse in den Variablen e und r und aktiviert das Event-Objekt. Schließlich muss anhand der Variablen e entschieden werden, ob eine Ausnahme ausgelöst oder die Variable r zurückgegeben werden soll. Diese Funktion implementiert eine Lösung, um eine asynchrone Callback-Funktion in einen synchronen Aufruf umzuwandeln, was die Lesbarkeit und Wartbarkeit der Funktion verbessern kann.

Asynchrone Programmierung in fibjs

In Fibjs können die meisten asynchronen Methoden (einschließlich E/A- und Netzwerkanforderungsmethoden usw.) gleichzeitig synchrone und 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:

Asynchroner Weg: Übergeben Sie eine Callback-Funktion, um das Ergebnis des Lesens der Datei zu verarbeiten, 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);
});

Dieser Ansatz eignet sich für Situationen, in denen Sie einige Vorgänge ausführen müssen, nachdem das Lesen der Datei abgeschlossen ist.

Synchroner Weg: Holen Sie sich den Inhalt der Datei, indem Sie keine Callback-Funktion ü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, und wir müssen nicht warten, bis die Rückruffunktion zum Abschluss des Lesens der Datei ausgeführt wird, bevor wir fortfahren. Dieser Ansatz 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 dieses Merkmal der Unterstützung sowohl synchroner als auch asynchroner Aufrufe es Entwicklern ermöglicht, unterschiedliche Methoden entsprechend ihren Anforderungen und Entwicklungsszenarien auszuwählen. In einigen Fällen ist der synchrone Code besser lesbar, einfacher zu warten und zu debuggen, während in einigen Fällen der asynchrone Code die Reaktionsfähigkeit und Leistung des Codes besser verbessern kann.

Allerdings müssen Sie auch bei der Verwendung der synchronen Methode darauf achten, dass diese Methode in einigen Szenarien die aktuelle Faser blockieren kann. Daher müssen wir die geeignete Programmiermethode entsprechend den tatsächlichen Anforderungen auswählen.

abschließend

In diesem Artikel haben wir den synchronen Programmierstil von fibjs und asynchrone Programmierlösungen, ihre Vorteile und Anwendungsszenarien vorgestellt. Wir haben erwähnt, dass Fibjs die betriebliche Komplexität reduzieren und die Effizienz der Codeentwicklung verbessern können, indem Fiber verwendet wird, 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, die Entwicklung, Test und Wartung erheblich erleichtern.

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

👉 【Heißes Update des Servermoduls】