Wait for pending runs to finish to proceed, Javascript

Question

That was the most practical example I could find.. is an example where the server sends 2 messages (or more) in a row and at "the same time", it does not check if there is something running, in case if there was it should wait until the end to send the new request.

I thought about creating a finite loop that waits for a variable to stay false to proceed, the variable would be the one that says that the work of the last request "ended" but I think this is gambiarra.

    // CONFIGURACOES DA DB //
var db = new Dexie('teste');

db.version(1).stores({
    sequences: '++id,of'
});
db.open().
catch ();
// CONFIGURACOES DA DB //

var executionOrder = []; // tem como deixar vazio sem ter undefined?

// isso foi o exemplo mais pratico que encontrei.. é um exemplo em que o servidor envia 4 mensagens (ou mais) seguidas e ao "mesmo tempo", ele nao checa se há algo sendo executado, no caso se houvesse ele deveria esperar até o fim para enviar a nova requisiçao

setInterval(function () {
    var newOrder = ['NOVO'].reverse();
    executionOrder = executionOrder.concat(newOrder);
    execute('INIT');
}, 4000);

setInterval(function () {
    var newOrder = ['APAGA'].reverse();
    executionOrder = executionOrder.concat(newOrder);
    execute('INIT');
}, 4000);

setInterval(function () {
    var newOrder = ['NOVO'].reverse();
    executionOrder = executionOrder.concat(newOrder);
    execute('INIT');
}, 4000);

function execute(req) {
    if (req == 'INIT') {
        callback();
    }  if (req == 'NOVO') {
        db.sequences.add({
            of: '0'
        });
        console.log('ADD 1');
        callback();
    }  if (req == 'APAGA') {
        db.sequences.where("of").equalsIgnoreCase('0').each(function (seq) {
            db.sequences.delete(seq.id);
        }).then(function () {
            console.log('DEL ALL');
            callback();
        });
    }
};

function callback() {
    if (executionOrder.length) {
        var next = executionOrder.pop();
        execute(next);
    }
}

if you take a setInterval will observe that everything goes well.. But with 2 or more it does not wait..

Working example: http://jsfiddle.net/uxnry1m6/

Answer 1

The general idea of using a variable as "semaphore" is OK (but using it in a loop would be even gambiarra, and would not work), and the way your code is structured can be done with a minimum of effort:

1. Create variable, initially allowing any execution:

   var semaforo = true; // Aberto
   

2. When you are going to run something time consuming and asynchronous, close the traffic light:

   if (req == 'APAGA') {
       semaforo = false; // Fechado
       db.sequences.where("of").equalsIgnoreCase('0').each(function (seq) {
           db.sequences.delete(seq.id);
       }).then(function () {
           console.log('DEL ALL');
           semaforo = true; // A execução demorada acabou, aberto de novo
           callback();
       });
   }
   

   Don’t forget to do this for every asynchronous operation by closing the traffic light before of it to begin (and not in the middle).

3. Finally, before performing anything check if the traffic light is open:

   function callback() {
       if (semaforo && executionOrder.length) {
   

   If it is not, it does not perform. But then when will it perform? Simple: what do you call the callback at the end of each run, it will check again if there are pending operations and do them.

In your case, that’s enough. But to make everything more robust, I suggest you modify the callback to perform not only one, but all pending actions, one at a time (don’t worry about the competition, the traffic light ensures that each operation waits for the last to be completed):

function callback() {
    while (semaforo && executionOrder.length) {
        var next = executionOrder.pop();
        execute(next);
    }
}

P.S. I also found a problem in how you are implementing a queue, reversing a list and using it as stack works well - as long as you do not add more elements to it. Because if you do, those elements will go to the front of the line, not the end, messing up the order. Instead, I suggest using the list as a queue, and not as a stack, calling portantoshiftem vez depop`:

var newOrder = ['NOVO']; // Sem o .reverse()
executionOrder = executionOrder.concat(newOrder);

...

var next = executionOrder.shift(); // Em vez de .pop()

Full example.