Is there any way to execute some code when a thread is killed via clearInterval?

Question

Is there anything like a "dispose" function or "thread shutdown hook" for a specific thread running via setInterval?

Answer 1

(function () {
    var _setInterval = window.setInterval,
        _clearInterval = window.clearInterval;



    window.setInterval = function (fn, time) {
        //Implement your hooks here, hopefully without side effects
        return _setInterval(fn, time);
    };

    window.clearInterval = function (id) {
        //Implement your hooks here, hopefully without side effects
        return _clearInterval(id);
    };

})()

From comments it became clear that you don't need hooking because you are in an environment that you control. In that case you can just write wrapper functions like myClearInterval etc. with same principle.

Answer 2

First off, as others have said, there are no threads in javascript (other than WebWorkers, but I don't think that's what you're talking about here.

All setInterval() does is call a function on a repeated basis - it isn't a thread, it isn't pre-emptive and it won't get called until all other javascript has stopped executing so the timer event can be processed. If your issue is that you want to dispose of some state when the interval is cleared so it will no longer be called, then you have two options:

1) You can use a javascript closure to store your state and when the interval is cleared, the closure will automatically be released.

2) You can create your own version of clearInterval that both clears the interval timer and cleans up your state.

The javascript closure option would look like this:

var interval;
function startMyInterval() {
    // sample state variables
    var state1 = 0;
    var state2 = [];
    var state3 = {whatever: "whatever"};

    interval = setInterval(function() {
        // javascript code here that can reference state1, state2 and state3
    }, 1000);
}

// then some time later when you want to stop the interval, you call clearInterval
// the closure is released and all the state variables are freed automatically
clearInterval(interval);

Or, if you want to do any other things when the interval is cleared, you can make your own function for clearing the interval that will not only release the closure, but also let you run any other code.

function clearMyInterval() {
    clearInterval(interval);
    // do any other cleanup you want to when the interval is stopped
}

I see that others have suggested hooking/replacing window.clearInterval() with your own function, but I prefer not to do that because it is unclear if that is a supported/documented feature and some system functions (more and more of them over time) are becoming protected so they cannot be replaced.