Come creare una cache in node.js che gestisce esplicitamente richieste simultanee duplicate per un'operazione legata alla CPU

Question

Quindi il nodo funziona perfettamente per me. Ho un'applicazione server molto specifica che accetta essenzialmente richieste per eseguire una particolare procedura legata alla CPU, ed esegue un programma C per farlo. Il fatto è che, se ho più client, è molto probabile che otterrò più versioni della stessa richiesta. Sarebbe una buona ottimizzazione gestirla in qualche modo in modo esplicito, implementando una cache con qualcosa di un lock su una particolare chiave, in modo che altri client attenderanno semplicemente che quella richiesta ritorni e copi la sua risposta.

Ma io sono nuovo per il nodo, quindi non so come farlo nel mio meccanismo di base del gestore di richieste router-nodo. Ovviamente potrei farlo in linguaggio x usando primitive di concorrenza di base, ma so che il nodo è orientato all'evento e penso che questo potrebbe essere fatto in modo elegante in un modo event. Idee?

Answer 1

Nel mondo lato client di JavaScript, si memorizzano in genere gli elementi in una matrice. Anch'io sono nuovo al nodo, quindi scusami se questa non è la risposta che stai cercando, ma vale la pena provare.

È possibile impostare un array vuoto all'avvio del server e memorizzare i risultati con un hash speciale di qualche tipo in base alla richiesta ricevuta. Questa sembra una soluzione fattibile.

E.g.

var http = require('http'); 
var cache = []; 
http.createServer(function (req, res) { 
    var obj; 
    if(!cache[key]) { 
     obj = .... // logic that gets results 
     cache[obj.key] = obj; 
    } else { 
     obj = cache[key]; 
    } 
}).listen(1337, "127.0.0.1"); 

Answer 2

Easy Peasy .. Node.js è a thread singolo, in modo che prima CPU richiesta legata sta bloccando il server comunque .. in modo Memoize i risultati. In sostanza, si imposta un hash con la chiave richiesta, e prima di chiamare il programma C, controllare l'hash. Se è lì, restituiscilo, sei fatto. In caso contrario, eseguire il programma C, incollare i risultati nell'hash alla chiave richiesta prima di ritornare, quindi il ritorno.

Answer 3

Diverse risposte sopra, ma nessuna realmente tratta le richieste parallele alla stessa risorsa correttamente.

Non è necessario preoccuparsi della concorrenza durante il controllo della chiave di cache, poiché il nodo è un ambiente a thread singolo. Tutte le tue azioni sono davvero atomiche. Tuttavia, tutte le operazioni asincrone nel nodo causeranno l'accettazione di ulteriori richieste. Quindi è necessario per gestire le richieste simultanee sovrapposte, qui risolto con la registrazione osservatori a un EventEmmiter:

var http = require('http'), EventEmitter = require('events').EventEmitter; 
var cache = {}; 

http.createServer(function (req, res) { 
    var key = someMagic(req), cached = cache[key]; // get some unique request identifier 

    if (!cached) { // if we've never seen this request before 
    cached = new EventEmitter(); // make this cache entry an event emitter 
    cached.status = 'running'; 
    handleAsyncRequest(function(result) { // your request handling is probably asynchronous, call this callback when you're done 
     cached.response = result; // memoize data 
     cached.status = 'finished'; 
     cached.emit('finished'); // notify all observers waiting for this request 
    }); 

    } else { 
    switch(cached.status) { // if existing request, check if it's still running or finished 
     case 'finished': 
     res.end(cached.response); // send cached response immediately if request has finished 
     break; 
     case 'running': 
     // subscribe as observer; send response when request is finished 
     cached.once('finished', function() { res.end(cached.response); }); 
     break; 
    } 
    } 
}).listen(1337, "127.0.0.1");