web-dev-qa-db-fra.com

Le framework électronique permet-il le multi-threading via des travailleurs Web?

J'ai du mal à chercher comment je ferais le multi-thread si je faisais une application électronique. Serait-ce avec les travailleurs Web?

javascriptelectron
12
smuggledPancakes

Dans le processus de rendu, vous pouvez créer Web Workers et ceux-ci s'exécutent dans leurs propres threads, mais l'intégration Node sera désactivée dans ces Web Workers car Node n'est pas thread-safe. Donc, si vous voulez exécuter quelque chose dans un thread séparé qui utilise Node, vous devrez créer un processus séparé. Vous pouvez le faire avec child_process.fork() , puis communiquer avec le nouveau processus en utilisant send() .

19
Vadim Macagon

Sur Electron, Node.js et Processus

Electron fonctionne sur les mêmes principes que Node. Dans node.js, les threads ne constituent pas l'unité d'exécution atomique. Vous travaillez dans la boucle d'événement et l'exécution est asynchrone par défaut. Voir ici pour plus de détails. Cela étant dit, vous pouvez activer plusieurs processus enfants dans node.js en les forgeant. 

Voici un exemple.

//forking a process using cluster
var cluster = require('cluster');
var http = require('http');
var numCPUs = 4;

if (cluster.isMaster) {
    for (var i = 0; i < numCPUs; i++) {
        cluster.fork();
    }
} else {
    http.createServer(function(req, res) {
        res.writeHead(200);
        res.end('process ' + process.pid + ' says hello!');
    }).listen(8000);
}

Crédit à Comment créer un cluster node.js pour accélérer vos applications. pour l'exemple.

Concepts spécifiques à l'électron

Pour revenir à Electron, vous devez connaître quelques concepts supplémentaires. Les processus dans Electron sont uniques en ce qu'ils viennent dans 2 saveurs. 

** Processus de rendu ** - Un processus qui contient une page Web. Ces processus sont créés dans un sandbox, comme le sont les pages Web classiques.

** Processus principal ** - Le processus qui initialise votre application. Il crée des processus de rendu et leurs pages Web. Il peut également servir de centre de communication pour tous les processus de rendu générés via rpc .

Voici la main.js partie de l’échantillon de le didacticiel Electron . Ceci est le processus principal appelant une fenêtre de navigateur. Prenez particulièrement note de la variable mainWindow.

'use strict';

const electron = require('electron');
const app = electron.app;  // Module to control application life.
const BrowserWindow = electron.BrowserWindow;  // Module to create native browser window.

// Keep a global reference of the window object, if you don't, the window will
// be closed automatically when the JavaScript object is garbage collected.
var mainWindow = null;

// Quit when all windows are closed.
app.on('window-all-closed', function() {
  // On OS X it is common for applications and their menu bar
  // to stay active until the user quits explicitly with Cmd + Q
  if (process.platform != 'darwin') {
    app.quit();
  }
});

// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
app.on('ready', function() {
  // Create the browser window.
  mainWindow = new BrowserWindow({width: 800, height: 600});

  // and load the index.html of the app.
  mainWindow.loadURL('file://' + __dirname + '/index.html');

  // Open the DevTools.
  mainWindow.webContents.openDevTools();

  // Emitted when the window is closed.
  mainWindow.on('closed', function() {
    // Dereference the window object, usually you would store windows
    // in an array if your app supports multi windows, this is the time
    // when you should delete the corresponding element.
    mainWindow = null;
  });
});

TL; DR;

Les threads n'existent pas dans Node.js et electron est un framework construit sur Node.js\io.js et Chromium. La fondation d'Electron est Node.js. Vous pouvez générer des processus enfants avec un forking dans node.js. 

12
Terrance

Selon le Multithreading docs:

Avec Web Workers, il est possible d'exécuter JavaScript dans des threads au niveau du système d'exploitation.

Tous les modules intégrés de Node sont pris en charge. Toutefois, aucun des modules intégrés d'Electron ou des modules avec des liaisons natives ne doit être utilisé dans Web Workers car ils ne sont pas conçus pour être thread-safe.

1
Jay

Découvrez Electron Edge. Il vous permet d'exécuter le code .NET et node.js dans un seul processus (aucun IPC requis, meilleures performances). Cela signifie que vous pouvez exploiter le modèle multi-threading .NET avec le single-threadedness de node.js.

Il fonctionnera sous Linux, Mac et Windows, grâce à .NET Core.

https://github.com/kexplo/electron-Edge

0
victtim