Existe-t-il des opérations de javascript atomiques pour traiter la nature asynchrone d'Ajax?

Je charge dynamiquement le code (fonctions) d'un serveur et je l'exécute en tant que code javascript, puis le stocke dans un tableau et j'exécute. Tous ces extraits de code doivent être exécutés exactement une fois. Le psuedocode suit en tant que tel

function fetch(foo){ if (foo in fooArray){ //Do Nothing else{ //Fetch foo via Ajax and execute foo() } } 

Le problème est beaucoup plus complexe, mais essentiellement si je délivre la commande ci-dessous

 fetch('someFunctionName'); fetch('someFunctionName'); fetch('someFunctionName'); fetch('someFunctionName'); 

Les quatre exécutent le if (foo in fooArray) et supposent qu'il ne figure pas dans le tableau, et tous les quatre vont chercher le code et l'exécuter. Je me souviens bien en apprenant les sémaphores et les mutex, y a-t-il des choses pour javascript.

JavaScript est une bonne langue qui fonctionne très bien avec des rappels asynchrones, des délais, des intervalles et des événements utilisateur, mais pas de problèmes de concurrence. Ceci est possible car le JavaScript est essentiellement un simple thread. Un morceau de code donné est toujours exécuté atomiquement et ne l'interrompt jamais par un autre thread exécutant JavaScript.

Votre fonction fetch() sera toujours exécutée sans aucune interruption. Si elle est exécutée dans le cadre du rappel AJAX et si plusieurs rappels AJAX sont en attente, ils seront mis en file d'attente.

Un autre exemple: si vous avez un gestionnaire d'événements affecté à un élément de saisie et que vous lancez l'événement plusieurs fois à la fois, les gestionnaires d'événements ne seront pas exécutés simultanément. Au lieu de cela, ils seront mis en file d'attente et exécutés séquentiellement. Cela s'applique également aux événements multiples déclenchés par setTimeout() / setInterval() .

Comme une note latérale: c'est l'une des raisons pour lesquelles node.js est si robuste: il utilise uniquement un thread unique et ne bloque jamais les E / S mais utilise des rappels plutôt que lorsque les données sont prêtes / se produit.

Javascript est essentiellement simple, donc vous n'avez pas besoin d'un mutex. Votre récupération pourrait configurer des indicateurs de sorte que les appels d'extraction ultérieurs pourraient éviter de faire des appels ajax, par exemple:

 var beingFetched = {};//map onflight -> callbacks function fetch(foo){ if (foo in fooArray){ //Do Nothing } else { if (beingFetched.foo) { //note empty array is truthy //register a callback var callback = function(r){ //anything you need to do wit the return object r //maybe even eval it. }; //the callback would more likely be an argument to fetch itself //or you could use a promise API instead so that you can at your will //register multiple callbacks - for error, for success etc. beingFetched.foo.push(callback); } else { beingFetched.foo = [];//truthy //Fetch foo via Ajax and execute $.ajax("getFoo/"+foo).done(function() { _.each(beingFetched.foo, function(cb){ cb.apply(cb,arguments); }); delete beingFetched.foo; }); } } }