Domanda Multi threading in Node.js?


Sto implementando socket.io in node.js per un progetto Windows Azure. Devo inviare dati a tutti i client connessi a intervalli regolari.

Sono nuovo di node.js ma credo che multi-threading non sia possibile. Lo scopo di socket.io è di supportare applicazioni in tempo reale, quindi esiste un modo per inviare dati ininterrottamente a tutti i miei client connessi a intervalli regolari e anche elaborare i dati che i client inviano simultaneamente al server socket.io?

MODIFICARE:

Questa è all'incirca la mia implementazione di socket.io

var io = require('socket.io').listen(80);

io.sockets.on('connection', function (socket) {
  socket.emit('first', "connected");

  socket.on('clientData', function (data) {
    //processing the data
  });
});

function requestQueue() {
// some processing
io.sockets.emit('broadcast', recordsQueue);
// should go to sleep for a time period
}

Essenzialmente voglio che il metodo requestQueue funzioni continuamente come un thread, che emetterà i dati ai client connessi a intervalli particolari. Inoltre, se il client invia dei dati all'evento "clientData", dovrei essere in grado di ricevere i dati e elaborarli.

Qualche idea su come posso farlo?

Grazie

La mia soluzione:

 var io = require('socket.io').listen(80);

io.sockets.on('connection', function (socket) {
  socket.emit('first', "connected");

  socket.on('clientData', function (data) {
    //processing the data
  });
});

function requestQueue() {
var sleepTime = 0;

// calcuate sleepTime 

io.sockets.emit('broadcast', recordsQueue);

// should go to sleep for a time period
   if(sleepTime !=0)
   setTimeout(function () { requestQueue() }, sleepTime);
}

11
2018-03-19 13:05


origine


risposte:


Come altri hanno suggerito, puoi ottenere ciò usando il setInterval o setTimeout funzioni per emettere periodicamente i dati ai client connessi. Sebbene tutto funzioni all'interno dello stesso thread di controllo, tutto l'I / O viene eseguito in modo asincrono, quindi l'applicazione sarà ancora reattiva. IE, tutti i dati ricevuti mentre il timer è in esecuzione saranno accodati ed elaborati dopo il ritorno della funzione timer.

Vedere Timer nel manuale node.js per ulteriori informazioni.


In una nota a margine, vorrai che l'applicazione node.js si concentri sull'elaborazione dell'I / O asincrono quasi in tempo reale, poiché questa è la forza di node.js. Se hai bisogno di fare calcoli pesanti, vorresti scaricarlo su un'altra discussione / processo in qualche modo, semplicemente facendo una richiesta asincrona per il risultato.


10
2018-03-20 17:29



Hai ragione, il nodo è single threaded. Ma fa un uso pesante degli eventi.

La strategia che devi seguire è ascoltare gli eventi sulle connessioni, recuperare i dati e quando desideri inviare i dati lo fai perché è stato emesso un altro evento.

Se dai un'occhiata agli esempi sulla pagina iniziale di socket.io, vedrai come usano gli eventi per avviare l'elaborazione degli stream. Il metodo on (eventName, function) è il modo in cui ascolti un evento in NodeJS.

Se desideri fare qualcosa in base al tempismo (generalmente una cattiva idea), dai un'occhiata al setInterval metodo.

server

    var io = require('socket.io').listen(80);

    io.sockets.on('connection', function (socket) {
      socket.emit('news', { hello: 'world' });
      socket.on('my other event', function (data) {
        console.log(data);
      });
    });

Cliente

    <script src="/socket.io/socket.io.js"></script>
    <script>
      var socket = io.connect('http://localhost');
      socket.on('news', function (data) {
        console.log(data);
        socket.emit('my other event', { my: 'data' });
      });
    </script>

11
2018-03-19 13:13



C'è anche una libreria Node.js per fare i thread: node-webworker-threads

https://github.com/audreyt/node-webworker-threads

Questo in pratica implementa il API browser Web Worker per node.js.

Nota che questo non è allineato con la filosofia di thread.ness di node.js, ma è lì se ne hai bisogno.


3
2018-03-23 16:58



La logica definita all'interno di setInterval ecc. Non funzionerà in un thread separato e alla fine bloccherà il main. Diciamo che ci sono 1000 utenti e hai chiamato il setTimeout ecc. Per 1000 volte, alla fine correranno e spenderanno quel tempo prezioso. Solo le operazioni di I / O finali non bloccano!

Potresti considerare di indagare nodeJX per il multithreading in node.js


0
2018-01-10 08:42



Multi threading in Node.js?

Sì ... è possibile in nodejs usando il modulo npm 'java4node', questo pacchetto è un metodo .multiThreading (attività, callback)         Questa funzione è utilizzata per eseguire il multithreading in modo java script

per usare questo modulo link: https://www.npmjs.com/package/java4node

corri raccomando

npm installa java4node

var java = require('java4node')

java.multiThreading({
           one: function(callback,parameters) {
               console.log("function one is running independently");
               callback()
           },
           two: function(callback,parameters) {
                console.log("function two is running independently");
               callback()
           },
           three: function(callback,parameters) {
                console.log("function three is running independently");
               callback()
           }
       }, function(err, results) {
           callback(err, results)
       });

0
2017-09-18 03:17