Multi-threading dans Node.js?

Question

J'implémente socket.io dans node.js pour un projet Windows Azure. Je dois envoyer des données à tous les clients connectés à intervalles réguliers.

Je suis nouveau sur node.js mais je suppose que le multi-thread n'est pas possible. Le but de socket.io est de prendre en charge les applications en temps réel, de sorte que je puisse envoyer des données en continu à tous mes clients connectés à intervalles réguliers et traiter toutes les données envoyées par les clients au serveur socket.io simultanément?

EDIT:

Ceci est à peu près ma mise en œuvre de 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 
} 

Essentiellement, je veux la méthode RequestQueue à exécuter en continu comme un fil, qui émettra des données aux clients connectés à des intervalles particuliers. Et aussi si le client envoie des données à l'événement "clientData", je devrais être en mesure de recevoir les données et de les traiter.

Une idée sur comment je peux le faire?

Merci

Ma solution:

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); 
} 

Answer 1

Comme d'autres l'ont suggéré, vous pouvez le faire en utilisant les fonctions setInterval ou setTimeout pour émettre périodiquement des données aux clients connectés. Bien que tout se passe dans le même thread de contrôle, toutes les E/S sont effectuées de manière asynchrone afin que votre application soit toujours réactive. IE, toutes les données reçues pendant l'exécution du temporisateur seront mises en file d'attente et traitées après le retour de la fonction de temporisation.

Voir le Timers dans le manuel node.js pour plus d'informations.

---

Sur une note de côté, vous voulez avoir votre attention d'applications Node.js sur le traitement d'E/S asynchrone en temps quasi-réel qui est la force de Node.js. Si vous avez besoin de faire de gros calculs, vous voudrez décharger cela d'une manière ou d'une autre, en faisant simplement une demande asynchrone pour le résultat. La logique que vous définissez à l'intérieur du setInterval, etc.

Answer 2

Vous avez raison, le nœud est un seul thread. Mais il fait un usage intensif des événements. La stratégie que vous devez adopter est d'écouter les événements sur les connexions, de récupérer des données et lorsque vous souhaitez renvoyer des données, vous le faites parce qu'un autre événement a été émis. Si vous jetez un oeil aux exemples de la page d'accueil socket.io, vous verrez comment ils utilisent les événements pour commencer à traiter les flux. La méthode on (eventName, function) est la façon dont vous écoutez un événement dans NodeJS.

Si vous souhaitez faire quelque chose en fonction du timing (généralement une mauvaise idée), jetez un oeil à la méthode setInterval.

serveur

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); 
     }); 
    }); 

client

<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> 

Answer 3

ne travaillera pas dans un thread séparé et bloquera finalement le principal. Disons qu'il y a 1000 utilisateurs et que vous avez appelé le setTimeout etc. pour 1000 fois, ils finiront par courir et passer du temps précieux. Seules les opérations d'E/S finales sont sans blocage!

Vous pouvez envisager d'étudier nodeJX pour le multithreading dans Node.js

Answer 4

Il y a aussi une bibliothèque Node.js pour les fils faire: noeud-WebWorker-fils

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

Ceci implémente essentiellement le Web Worker browser API pour node.js. Notez que cela ne correspond pas à la philosophie de thread.js d'un seul thread, mais il est là si vous en avez besoin.

Answer 5

Multi-threading dans Node.js?

Oui ..il est possible dans nodejs en utilisant le module de NPM 'de java4node', il ce paquet une méthode est .multiThreading (tâches, callbacks) Cette fonction est l'utilisation pour effectuer multithreading manière java script

pour en utilisant ce module lien: https://www.npmjs.com/package/java4node

course félicitons

NPM installer 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) 
     });