Comment écrire des fonctions véritablement non bloquantes dans Node.js ?

Manière correcte d'écrire une fonction non bloquante dans Node.js

Le paradigme non bloquant est crucial dans Node.js pour atteindre hautes performances. Cependant, il peut être difficile d'écrire des fonctions véritablement non bloquantes qui n'entravent pas la progression de la boucle d'événements.

Comprendre le comportement non bloquant

Encapsuler le code dans une promesse ne le rend pas intrinsèquement non bloquant. La fonction d'exécution de Promise est exécutée de manière synchrone, ce qui signifie que le code de longue durée qu'elle contient bloquera l'exécution d'autres opérations.

Exemple : fonction de blocage enveloppée par promesse

Considérez la fonction suivante :

function longRunningFunc(val, mod) {
    return new Promise((resolve, reject) => {
        let sum = 0;
        for (let i = 0; i < 100000; i++) {
            for (let j = 0; j < val; j++) {
                sum += i + j % mod;
            }
        }
        resolve(sum);
    });
}

Bien que cette fonction renvoie une promesse, le code dans l'exécuteur est blocage. La boucle d'événements attendra la fin de ce code avant d'exécuter d'autres opérations.

Simulation de l'asynchronicité avec setTimeout

Une approche pour émuler un comportement non bloquant dans ce cas consiste à utiliser setTimeout :

function longRunningFunc(val, mod) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            let sum = 0;
            for (let i = 0; i < 100000; i++) {
                for (let j = 0; j < val; j++) {
                    sum += i + j % mod;
                }
            }
            resolve(sum);
        }, 10);
    });
}

Ce code planifie l'exécution de la boucle de longue durée après 10 millisecondes retard. Cependant, il bloque toujours pendant cette période d'exécution retardée.

Véritables approches non bloquantes

Pour créer des fonctions véritablement non bloquantes, vous devez utiliser des techniques qui déplacent le code exécution en dehors du thread principal Node.js :

• Processus enfants : Créer un processus distinct pour gérer les tâches de longue durée.
• Worker Threads : Utilisez la fonctionnalité expérimentale Worker Threads de Node.js pour créer plusieurs threads au sein d'un seul processus.
• Code natif : Écrivez du C ou d'autres extensions de code natif qui utilisent des appels système asynchrones ou threads.
• API asynchrones existantes : Tirez parti des opérations asynchrones fournies par les modules principaux de Node.js, telles que les E/S de fichiers avec fs.readFile, les requêtes HTTP avec http.get ou les requêtes de base de données avec mangouste.connect.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!