Having an object to store data.

var store = {
    elements: [],
    eventsEnabled: true,
    addElement: function(element) {
        this.elements.push(element);
        if (this.eventsEnabled) {
            // Code that triggers event, calls handlers... whatever
        }
    }
};

The act of storing data es from two events (kind of two producers). First "producer" does not trigger any event:

setInterval(function() {
    store.eventsEnabled = false;
    store.addElement('hello');
    store.eventsEnabled = true;
}, 12000);

Second does trigger events:

setInterval(function() {
    store.addElement('bye');
}, 7000);

The question is, can the second producer break execution flow of first producer?

I mean, if producer 1 disables events and, before finishing execution (and therefore before events are enabled again), producer 2 starts its execution and adds its element, then no events will be triggered. Is that possible? Can that happen?

If so, how can this code be converted to be kind-of thread-safe?

Having an object to store data.

var store = {
    elements: [],
    eventsEnabled: true,
    addElement: function(element) {
        this.elements.push(element);
        if (this.eventsEnabled) {
            // Code that triggers event, calls handlers... whatever
        }
    }
};

The act of storing data es from two events (kind of two producers). First "producer" does not trigger any event:

setInterval(function() {
    store.eventsEnabled = false;
    store.addElement('hello');
    store.eventsEnabled = true;
}, 12000);

Second does trigger events:

setInterval(function() {
    store.addElement('bye');
}, 7000);

The question is, can the second producer break execution flow of first producer?

I mean, if producer 1 disables events and, before finishing execution (and therefore before events are enabled again), producer 2 starts its execution and adds its element, then no events will be triggered. Is that possible? Can that happen?

If so, how can this code be converted to be kind-of thread-safe?

• javascript
• jquery
• multithreading
• oop
• thread-safety

• stackoverflow./questions/9298839/… – Amith Commented Jul 13, 2021 at 0:54

3 Answers 3

JavaScript is single-threaded. A function cannot be interrupted, so you can be sure each function block will plete before another begins.

(However, if a function makes an asynchronous call, other functions may execute before the asynchronous operation starts. That doesn't happen in your code, though, that I can see, besides the setTimeout calls, and you can be sure those will execute in the correct order.)

Would it not be more sensible to pass the eventsEnabled in as a parameter to the addElement method?

var store = {
    elements: [],
    addElement: function(element,eventsEnabled) {
        this.elements.push(element);
        if (eventsEnabled) {
            // Code that triggers event, calls handlers... whatever
        }
    }
};

First:

setInterval(function() {
    store.addElement('hello',false);
}, 12000);

Second:

setInterval(function() {
    store.addElement('bye',true);
}, 12000);

Further to @Jamiec's suggestion, you could also look at passing the event function in as well:

var store = {
    elements: [],
    addElement: function(element, callback) {
        this.elements.push(element);
        if (callback !== undefined) {
            callback();
            // Common code that triggers event, calls handlers... whatever
            alert("I'm Common Event Code");
        }
    }
};​

Used as such:

setInterval(function() {
    store.addElement('hello', function(){ alert("I'm Special Event Code!"); });
}, 12000);

Thus, if an event is needed, you can pass it in, else just leave it out.