Sémaphore Javascript / test-and-set / lock?

Question

Est-il une telle chose comme un test atomique-et-jeu, sémaphore, ou d'un lock dans le Javascript?

J'ai javascript invocation asynchrone processus d'arrière-plan via un protocole personnalisé (le processus de fond littéralement s'exécute dans un processus distinct, sans rapport avec le navigateur). Je crois que je suis en cours d'exécution dans une condition de concurrence; les processus d'arrière-plan retours entre mon test et mon set, visser les choses sur le javascript côté. J'ai besoin d'un test-et-l'opération de l'ensemble pour en faire un véritable sémaphore.

Voici le code javascript qui tente de détecter les processus d'arrière-plan et mettre en file d'attente jusqu':

Call = function () {

var isRunning = true,
    queue = [];

return  {
    // myPublicProperty: "something",

    call: function (method) {
            if (isRunning) {
                console.log("Busy, pushing " + method);
                queue.push(method);
            } else {
                isRunning = true;
                objccall(method);
            }
        },

        done: function() {
            isRunning = false;
            if (queue.length > 0) {
                Call.call(queue.shift());
            }
        }
    };
}();

L'appel est un singleton qui met en œuvre les files d'attente; quelqu'un qui veut se prévaloir d'un processus externe fait Appel.call("quelque chose") .

Des idées?

Answer 1

JavaScript n'a pas de sémantique de verrouillage parce que JS n'est pas un multi threaded langue. Plusieurs threads peuvent fonctionner simultanément complètement distinctes contextes, par exemple. HTML5 threads de travail, ou dans des choses comme plusieurs instances de JavaScriptCore API objet de contexte (je suppose SpiderMonkey a un concept similaire). Ils ne peuvent pas avoir un état partagé, donc, en substance, toute exécution est atomique.

Ok, alors maintenant, vous avez donné votre code je suppose que vous avez quelque chose qui ressemble à:

External Process:
<JSObject>.isRunning = true;
doSomething()
<JSObject>.done()

Ou quelque chose du genre (à l'aide d'Api appropriées). Dans ce cas, je m'attends à la JS moteur à bloc si le JS est en cours d'exécution dans le cadre de votre js objet (qui est ce que JavaScriptCore le ferait), à défaut que vous aurez probablement besoin de mettre un verrou manuel en place autour de js exécution.

Ce moteur utilisez-vous pour faire tout cela? Je demande parce que basé sur votre description, il semble que vous êtes un indicateur à partir d'un thread secondaire à partir d'un non-JS la langue à l'aide de l'API C/C++ fournis par la langue, et la plupart JS moteurs de supposer que toute manipulation de l'état fait via l'API sera survenant sur un seul thread, généralement le même thread que l'ensemble de l'exécution de sur.

Answer 2

Une recherche rapide dans Google pour "javascript mutex" a renvoyé cet article (Implémentation de l'exclusion mutuelle dans JavaScript).

Answer 3

Peut-être que vous pourriez implémenter un sémaphore de base entier, ajoutez simplement la variable dans le DOM et verrouillez-la / déverrouillez-la et assurez-vous que vos fonctions la vérifient, sinon timeout them =)

Si vous utilisez un framework tel que Mootools, vous pouvez essayer de gérer le flux de l'application avec des événements tels que onComplete, etc.

bonne chance

Answer 4

J'ai des trucs ajax qui remplissent des listes de sélection, il me fallait le verrouiller pour que je fasse quelque chose comme ça. Je pense que vous pourriez probablement faire les choses plus simplement en utilisant des différés et des tuyaux ou quelque chose.

 var semaphore=[];

function myFunc(arg){
   var dfd;
   $.when(semaphore[table]).done(
      function(){
            dfd=myFuncInner(arg);
      }
      );
return dfd;
}

function myFuncInner(table){
semaphore[arg] = new $.Deferred();
... 
somethingasynchronous({
    semaphore[arg].resolve();
});

return  semaphore[arg];
}