Difficult to believe, but yes AJAX in jQuery version 1.4.2 does leak. I had a nasty suspicion about this and a reported bug 6242 confirmed it. Not being comfortable with taking the recommended fix at face value I decided to look into this myself.
Before I continue I want to encourage you to read my previous posts XMLHttpRequest Leak in IE 7/8 and xmlhttprequest-leak-in-ie-78-forgot-the-abort-thing to fully understand my reasoning in this post.
To test the severity of the leak I wrote a simple test.
test-jquery-ajax-leak6.html
<html> <head> <title>jQuery Ajax Leak Demo</title> <script src="jquery-1.4.2.js"></script> <script> $(document).ready(function(){ //no caching of calls to for better accuracy $.ajaxSetup({cache: false}); var interval; var i = 1000; //number of calls $('#button1').click(function(){ interval = setInterval(makeLeak, 50); }); function makeLeak(){ $.get('test6.php', function(){ if(--i === 0){ //all calls done. Cleanup clearInterval(interval); interval = null; alert('All Done'); } }); }; }); </script> </head> <body> <button id="button1" >Fire</button> </body> </html>
Nothing fancy here. 1000 calls at interval of 50ms. Also, the test6.php contains just a dummy echo:
test6.php
<?php echo ''; ?>
If I run the html file in sIEve I get this:
Only making the AJAX calls and doing zero data processing the memory consumption increased from 15,600 bytes to 41,428 bytes! More than 2.5 times. For 10,000 iterations the memory went up from 15,680 to 257,208 bytes. We have a leak!
To see what was going on I dissected the jQuery AJAX code. For sake of clarity I have removed code not relevant to this discussion. The pared down code from ‘jquery-1.4.2.js’ looks like this:
ajax: function( origSettings ) { var requestDone = false; // Create the request object var xhr = s.xhr(); if ( !xhr ) { return; } // Open the socket // Passing null username, generates a login popup on Opera (#2865) if ( s.username ) { xhr.open(type, s.url, s.async, s.username, s.password); } else { xhr.open(type, s.url, s.async); } // Wait for a response to come back var onreadystatechange = xhr.onreadystatechange = function( isTimeout ) { // The request was aborted if ( !xhr || xhr.readyState === 0 || isTimeout === "abort" ) { //this code removed requestDone = true; if ( xhr ) { xhr.onreadystatechange = jQuery.noop; } // The transfer is complete and the data is available, or the request timed out } else if ( !requestDone && xhr && (xhr.readyState === 4 || isTimeout === "timeout") ) { requestDone = true; xhr.onreadystatechange = jQuery.noop; //fire success callback success(); //fire complete callback complete(); //more code removed here if ( isTimeout === "timeout" ) { xhr.abort(); } // Stop memory leaks if ( s.async ) { xhr = null; } } }; // Override the abort handler, if we can (IE doesn't allow it, but that's OK) // Opera doesn't fire onreadystatechange at all on abort try { var oldAbort = xhr.abort; xhr.abort = function() { if ( xhr ) { oldAbort.call( xhr ); } onreadystatechange( "abort" ); }; } catch(e) { } // Send the data try { xhr.send( type === "POST" || type === "PUT" || type === "DELETE" ? s.data : null ); } catch(e) { jQuery.handleError(s, xhr, null, e); // Fire the complete handlers complete(); } // return XMLHttpRequest to allow aborting the request etc. return xhr; }
Stepping through the function:
1. An instance of the ‘XMLHttpRequest’ object is created and put in variable named ‘xhr’.
2. the ‘open’ method is executed in preparation for ‘send’.
3. A handler is defined for the callback ‘xhr.onreadystatechange’ .
4. The ‘abort’ method is over-ridden.
5. The ‘send’ request is made.
6. ‘xhr’ the reference to the ‘XMLHttpRequest’ object instance is returned.
When the call returns it fires the ‘xhr.onreadystatechange’ handler. The following sequence of event takes place:
1. Assuming that the call is complete(readyState == 4) the else part of the if is executed.
2. To prevent leaks the handler is cleaned up like so: xhr.onreadystatechange = jQuery.noop;. (jQuery.noop is a jQuery no-operation function and is defined as noop: function() {}(~Line 520))
3. The success callback handler is called.
4. The complete callback handler is called.
5. If there is a timeout call is aborted.
6. Finally to avoid leaks xhr is set to null. (See my previous post to see why)
So, if the ‘xhr.onreadystatechange’ callback handler is being cleaned up and ‘xhr’ is being set to null why is there a leak? It is because the ‘abort’ method is over-ridden but not cleaned up. To do that we need to replace(around line 5220):
// Stop memory leaks
if ( s.async ) {
xhr = null;
}
with
// Stop memory leaks
if ( s.async ) {
xhr.abort = jQuery.noop;
xhr = null;
}
Let’s run the test again:
As you can see the consumption has stabilized around 18K. Also note how the memory is being released(-green) as the number of calls progress.
To my satisfaction I also found the official fix
Happy computing!