Veröffentlichung einer Bibliothek für die synchrone Ausführung asynchroner Prozesse in JS/TS

Ich habe eine Bibliothek namens sync-actions veröffentlicht, die es ermöglicht, asynchrone Prozesse synchron in JavaScript/TypeScript auszuführen. Insbesondere in TypeScript können Sie definierte Funktionen typsicher aufrufen. Es ist für den Einsatz in Fällen gedacht, in denen Sie asynchrone Prozesse innerhalb von Funktionen ausführen möchten, die Sie nicht als asynchron markieren möchten (oder können).

Merkmale

• Verwendet Node.js worker_threads
  • Asynchrone Prozesse werden in einem Sub-Thread ausgeführt und der Haupt-Thread wartet synchron auf deren Abschluss.
• Typsichere Funktionsaufrufe
  • In TypeScript können Sie die Typinformationen definierter Funktionen nutzen.
• Veröffentlicht als Native ESM
  • Dies wird dadurch vereinfacht, dass CommonJS nicht unterstützt wird.

Repository

https://github.com/koyopro/sync-actions

Verwendung

Installation

Es wird als npm-Paket veröffentlicht, also installieren Sie es bitte mit npm install oder ähnlichem.

npm install sync-actions

Grundlegende Verwendung

Durch Übergabe einer asynchronen Funktion, die ein Promise-Objekt an defineSyncWorker() zurückgibt, können Sie die Schnittstelle definieren und den Arbeitsthread mit launch() starten. Es wird davon ausgegangen, dass die Datei, die den Worker definiert, getrennt von anderen Verarbeitungsdateien erstellt wird.

// worker.js
import { defineSyncWorker } from "sync-actions";

export const { actions, worker } = defineSyncWorker(import.meta.filename, {
  ping: async () => {
    // Execute asynchronous process,
    await new Promise((resolve) => setTimeout(resolve, 1000));
    // Return the result as a return value
    return "pong";
  }
}).launch();

// main.js
import { actions, worker } from "./worker.js";

// You can execute asynchronous functions synchronously
console.log(actions.ping()); // => "pong" is output after 1 second

worker.terminate();

Typsichere Funktionsaufrufe

In TypeScript können Sie mit defineSyncWorker definierte Funktionen typsicher aufrufen.

// worker.ts
import { defineSyncWorker } from "sync-actions";

export const { actions, worker } = defineSyncWorker(import.meta.filename, {
  // By specifying the types of arguments and return values, type-safe calls are possible
  add: async (a: number, b: number): Promise<number> => {
    return a + b;
  }
}).launch();

// main.ts
import { actions, worker } from "./worker.js";

// Type-safe call
actions.add(1, 2); // => 3 (number)

// @ts-expect-error
actions.add("1", 2);
// => Argument of type 'string' is not assignable to parameter of type 'number'

worker.terminate();

Hintergrund

Der Inhalt ist bisher derselbe wie in der README-Datei, daher werde ich den Hintergrund seiner Erstellung beschreiben.

Ich entwickle einen ORM namens Accel Record.¹ Im Gegensatz zu allgemeinen ORMs ist Accel Record darauf ausgelegt, DB-Zugriffe mit einer synchronen Schnittstelle durchzuführen.² Der Teil, der DB-Zugriffe synchron ausführt wurde durch die Ausführung asynchroner Prozesse in einem Unterprozess realisiert, der mit dem Modul child_process gestartet wurde.³ Ich dachte, das durch die Verwendung worker_threads anstelle von child_process, ich könnte den Overhead zur Laufzeit reduzieren.

Accel Record ist auch hinsichtlich der Benutzerfreundlichkeit so konzipiert, dass es dem Active Record von Ruby on Rails ähnelt, und eines der Dinge, die ich in Zukunft erreichen möchte, ist die Erstellung einer Bibliothek wie CarrierWave. Mit CarrierWave können Sie Bilder beim Speichern von Datensätzen auf externen Speicherdiensten (z. B. AWS S3) speichern. Um dies mit Accel Record zu erreichen, ist es erforderlich, asynchrone Prozesse wie Bild-Uploads synchron auszuführen. Ich erwarte, dass dieser Prozess durch die Verwendung von worker_threads anstelle von Unterprozessen schneller ausgeführt werden kann.

Also habe ich einmal nach einer Bibliothek gesucht, die asynchrone Prozesse mithilfe von worker_threads synchron ausführt. Ich habe mehrere Bibliotheken wie Synckit und Deasync gefunden, aber keine davon hat bei mir wie erwartet funktioniert, also habe ich beschlossen, meine eigene zu erstellen. Da ich gerade dabei war, dachte ich, ich würde eine Schnittstelle erstellen, die typsicher mit TypeScript verwendet werden kann.

Weitere interne Details

• Bis der mit worker_threads gestartete asynchrone Prozess im Sub-Thread abgeschlossen ist, wird der Haupt-Thread mit Atomic.wait() blockiert.
• MessageChannel wird für die Kommunikation zwischen Threads verwendet. Der Quellcode von Synckit war für diesen Teil der Implementierung sehr hilfreich.
• Wenn Sie einen Worker mit worker_threads starten, ist es notwendig, die .ts-Datei in .js zu transpilieren. Für diesen Teil verwende ich esbuild.
• Beim Starten eines Workers wollte ich den transpilierten Quellcode als String zur Ausführung an den Worker übergeben, aber es funktionierte in meiner Umgebung nicht richtig. Dies ist der Teil, mit dem ich am meisten zu kämpfen hatte. Am Ende habe ich die Datei unter node_modules geschrieben und ihren Pfad an den Worker übergeben. Diese Methode erwies sich als die stabilste.

---

1. Einführung in „Accel Record“: Ein TypeScript-ORM mit dem Active Record-Muster ↩

2. Warum wir eine synchrone API für das neue TypeScript ORM eingeführt haben ↩

3. Techniken für synchronen DB-Zugriff in TypeScript ↩

Das obige ist der detaillierte Inhalt vonVeröffentlichung einer Bibliothek für die synchrone Ausführung asynchroner Prozesse in JS/TS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!