Quante richieste simultanee AJAX (XmlHttpRequest) sono consentite nei browser più diffusi?

358

In Firefox 3, la risposta è 6 per dominio: non appena viene attivato un settimo XmlHttpRequest (su qualsiasi scheda) allo stesso dominio, viene messo in coda fino a quando uno degli altri 6 finisce.

Quali sono i numeri per gli altri principali browser?

Inoltre, ci sono modi per aggirare questi limiti senza che i miei utenti modifichino le impostazioni del loro browser? Ad esempio, ci sono limiti al numero di richieste jsonp (che utilizzano l'iniezione di tag script anziché un oggetto XmlHttpRequest)?

Background: i miei utenti possono fare richieste XmlHttp da una pagina Web al server, chiedendo al server di eseguire comandi ssh su host remoti. Se gli host remoti sono inattivi, il comando ssh impiega alcuni minuti per fallire, impedendo eventualmente ai miei utenti di eseguire ulteriori comandi.

ajax browser xmlhttprequest

— Michael Gundlach
fonte

Pensando alla tua situazione, qual è la fattibilità del ping del tubo remoto per vedere se è su o giù? Questo non risponderà alla tua domanda, ma potrebbe essere un flusso di lavoro migliore.

— Bob,

1

Grazie Bob, questo è uno dei due approcci che avevo programmato di risolvere questo problema: ho considerato di menzionarlo nella domanda ma ho deciso che era fuori tema. (Un altro approccio è quello di avere il server, che controllo, il timeout delle richieste SSH.)

— Michael Gundlach,

1

Penso che tu abbia praticamente la tua risposta ... è più che sicuro supporre che Safari e Chrome supportino almeno 2, quindi puoi sempre presumere 2.

— Rex M

1

Utilizzando Chrome 2.0.172.28 su Windows Vista ho ottenuto 6 connessioni simultanee.

— Callum,

2

Ho appena trovato questa pagina stevesouders.com/blog/2008/03/20/… che fornisce alcuni altri numeri e una discussione al riguardo.

— David Johnstone,

143

Un trucco che puoi usare per aumentare il numero di connessioni simultanee è quello di ospitare le tue immagini da un sottodominio diverso. Queste saranno trattate come richieste separate, ogni dominio è ciò che sarà limitato al massimo simultaneo.

IE6, IE7 - hanno un limite di due. IE8 è 6 se si dispone di una banda larga - 2 (se è un dial-up).

— peso
fonte

4

No, i limiti sono imposti al dominio. Quindi potresti tecnicamente ottenere FF fino a 12 connessioni se avessi un sottodominio in aggiunta al tuo sito.

— Bob,

1

Quindi, se ho capito, FF limita tutte le richieste (a un singolo dominio) a 6 - non solo XmlHttpRequests a un singolo dominio. E altri browser fanno la stessa cosa con limiti diversi. Corretta?

— Michael Gundlach,

1

Oh sì, se hai una pagina con mille immagini, le scaricherà in gruppi di sei. Credo che la maggior parte degli altri browser mainstream funzioni allo stesso modo.

— Bob,

7

Wow. Questo è un buon trucco. Questo spiega anche perché i server di tile per i motori di mappe creano un numero di sottodomini falsi (in genere qualcosa come maps1.whatever.com, maps2.whatever.com, maps3.whatever.com) per accelerare le cose.

— meawoppl,

2

@AMember, il browser mantiene in parallelo il numero massimo consentito di ajax simultanei. Prova la mia risposta qui sotto se vuoi vedere in azione

— Luis Siquot,

103

I risultati di rete su Browserscope ti daranno sia Connessioni per Nome host che Max Connessioni per i browser più diffusi. I dati vengono raccolti eseguendo test sugli utenti "in the wild", quindi rimarranno aggiornati.

— Kevin Hakanson
fonte

3

Sfortunatamente questo non sembra aggiornato a distanza

— Dave Lawrence il

@DaveLawrence Ho appena controllato e l'intero set di dati sembra contenere Chrome 60 e 61, che è abbastanza aggiornato.

— Simon East,

24

Con IE6 / IE7 è possibile modificare il numero di richieste simultanee nel registro. Ecco come impostarlo su quattro ciascuno.

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings]
"MaxConnectionsPerServer"=dword:00000004
"MaxConnectionsPer1_0Server"=dword:00000004

— brianegge
fonte

15

-1. OP ha detto without having my users modify their browser settings. Inoltre, non è pratico poiché si dovrebbe fare questo su ciascun client.

— Razort4x,

23

Questa è comunque una cosa molto utile da sapere, legata a questo problema. Forse sarebbe stato meglio postato in un commento che come risposta?

— JD Smith,

7

Ho appena controllato con www.browserscope.org e con IE9 e Chrome 24 puoi avere 6 connessioni simultanee a un singolo dominio e fino a 17 a più di uno.

— xmorera
fonte

6

Secondo IE 9 - Cosa è cambiato? sul blog di HttpWatch, IE9 ha ancora un limite di 2 connessioni su VPN.

Utilizzando una VPN Still Clobbers IE 9 Performance

In precedenza abbiamo segnalato il ridimensionamento del numero massimo di connessioni simultanee in IE 8 quando il PC utilizza una connessione VPN. Ciò è accaduto anche se il traffico del browser non ha superato tale connessione.

Sfortunatamente, IE 9 è influenzato dalle connessioni VPN allo stesso modo:

— Kevin Hakanson
fonte

6

Ho scritto un tester AJAX per file singolo. Divertirsi!!! Solo perché ho avuto problemi con il mio provider di hosting

<?php /*

Author:   Luis Siquot
Purpose:  Check ajax performance and errors
License:  GPL
site5:    Please don't drop json requests (nor delay)!!!!

*/

$r = (int)$_GET['r'];
$w = (int)$_GET['w'];
if($r) { 
   sleep($w);
   echo json_encode($_GET);
   die ();
}  //else
?><head>
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>
<script type="text/javascript">

var _settimer;
var _timer;
var _waiting;

$(function(){
  clearTable();
  $('#boton').bind('click', donow);
})

function donow(){
  var w;
  var estim = 0;
  _waiting = $('#total')[0].value * 1;
  clearTable();
  for(var r=1;r<=_waiting;r++){
       w = Math.floor(Math.random()*6)+2;
       estim += w;
       dodebug({r:r, w:w});
       $.ajax({url: '<?php echo $_SERVER['SCRIPT_NAME']; ?>',
               data:    {r:r, w:w},
               dataType: 'json',   // 'html', 
               type: 'GET',
               success: function(CBdata, status) {
                  CBdebug(CBdata);
               }
       });
  }
  doStat(estim);
  timer(estim+10);
}

function doStat(what){
    $('#stat').replaceWith(
       '<table border="0" id="stat"><tr><td>Request Time Sum=<th>'+what+
       '<td>&nbsp;&nbsp;/2=<th>'+Math.ceil(what/2)+
       '<td>&nbsp;&nbsp;/3=<th>'+Math.ceil(what/3)+
       '<td>&nbsp;&nbsp;/4=<th>'+Math.ceil(what/4)+
       '<td>&nbsp;&nbsp;/6=<th>'+Math.ceil(what/6)+
       '<td>&nbsp;&nbsp;/8=<th>'+Math.ceil(what/8)+
       '<td> &nbsp; (seconds)</table>'
    );
}

function timer(what){
  if(what)         {_timer = 0; _settimer = what;}
  if(_waiting==0)  {
    $('#showTimer')[0].innerHTML = 'completed in <b>' + _timer + ' seconds</b> (aprox)';
    return ;
  }
  if(_timer<_settimer){
     $('#showTimer')[0].innerHTML = _timer;
     setTimeout("timer()",1000);
     _timer++;
     return;
  }
  $('#showTimer')[0].innerHTML = '<b>don\'t wait any more!!!</b>';
}


function CBdebug(what){
    _waiting--;
    $('#req'+what.r)[0].innerHTML = 'x';
}


function dodebug(what){
    var tt = '<tr><td>' + what.r + '<td>' + what.w + '<td id=req' + what.r + '>&nbsp;'
    $('#debug').append(tt);
}


function clearTable(){
    $('#debug').replaceWith('<table border="1" id="debug"><tr><td>Request #<td>Wait Time<td>Done</table>');
}


</script>
</head>
<body>
<center>
<input type="button" value="start" id="boton">
<input type="text" value="80" id="total" size="2"> concurrent json requests
<table id="stat"><tr><td>&nbsp;</table>
Elapsed Time: <span id="showTimer"></span>
<table id="debug"></table>
</center>
</body>

Modifica:
r significa riga e w tempo di attesa.
Quando si preme inizialmente il pulsante di avvio 80 (o qualsiasi altro numero) di una richiesta Ajax simultanea vengono lanciati da JavaScript, ma come è noto, vengono inviati dal browser. Inoltre sono richiesti al server in parallelo (limitato a un certo numero, questo è il fatto di questa domanda). Qui le richieste vengono risolte sul lato server con un ritardo casuale (stabilito da w). All'ora di inizio viene calcolato tutto il tempo necessario per risolvere tutte le chiamate Ajax. Al termine del test, è possibile vedere se ha impiegato la metà, il terzo, il quarto, ecc. Del tempo totale, deducendo il parallelismo tra le chiamate al server. Questo non è rigoroso, né preciso, ma è bello vedere in tempo reale come vengono completate le chiamate ajaxs (vedere la croce in arrivo). Ed è uno script autonomo molto semplice per mostrare le basi di Ajax.
Naturalmente, ciò presuppone che il lato server non stia introducendo alcun limite aggiuntivo.
Utilizzare preferibilmente in combinazione con il pannello net firebug (o equivalente del browser)

— Luis Siquot
fonte

quindi confermo, FF3 lancia fino a sei richieste simultanee

— Luis Siquot,

Puoi spiegare cosa hai fatto qui? Che cos'è r & w? La schermata di stampa del risultato dell'analisi sarebbe molto apprezzata

— Royi Namir il

4

Ha scritto il mio test. testato il codice su StackOverflow, funziona bene mi dice che Chrome / FF può fare 6

var change = 0;
var simultanius = 0;
var que = 20; // number of tests

Array(que).join(0).split(0).forEach(function(a,i){
    var xhr = new XMLHttpRequest;
    xhr.open("GET", "/?"+i); // cacheBust
    xhr.onreadystatechange = function() {
        if(xhr.readyState == 2){
            change++;
            simultanius = Math.max(simultanius, change);
        }
        if(xhr.readyState == 4){
            change--;
            que--;
            if(!que){
                console.log(simultanius);
            }
        }
    };
    xhr.send();
});

funziona per la maggior parte dei siti Web che possono attivare eventi di modifica pronti in momenti diversi. (aka: vampate di calore)

Ho notato sul mio server node.js che ho dovuto generare almeno 1025 byte per attivare l'evento / flush. altrimenti gli eventi attiverebbero tutti e tre gli stati contemporaneamente quando la richiesta è completa, quindi ecco il mio backend:

var app = require('express')();

app.get("/", function(req,res) {
    res.write(Array(1025).join("a"));
    setTimeout(function() {
        res.end("a");
    },500);
});

app.listen(80);

Aggiornare

Ho notato che ora puoi avere fino a 2x richieste se stai usando sia xhr che fetch api allo stesso tempo

var change = 0;
var simultanius = 0;
var que = 30; // number of tests

Array(que).join(0).split(0).forEach(function(a,i){
    fetch("/?b"+i).then(r => {
        change++;
        simultanius = Math.max(simultanius, change);
        return r.text()
    }).then(r => {
        change--;
        que--;
        if(!que){
            console.log(simultanius);
        }
    });
});

Array(que).join(0).split(0).forEach(function(a,i){
    var xhr = new XMLHttpRequest;
    xhr.open("GET", "/?a"+i); // cacheBust
    xhr.onreadystatechange = function() {
        if(xhr.readyState == 2){
            change++;
            simultanius = Math.max(simultanius, change);
        }
        if(xhr.readyState == 4){
            change--;
            que--;
            if(!que){
                document.body.innerHTML = simultanius;
            }
        }
    };
    xhr.send();
});

Espandi frammento

— Infinito
fonte

Dice 19 sul mio, è rotto?

— PauAI,

Firefox Developer Edition 57.0b12 dice 2.

— AnthonyB

0

Credo che ci sia un numero massimo di richieste http simultanee che i browser invieranno allo stesso dominio, che è nell'ordine di 4-8 richieste a seconda delle impostazioni e del browser dell'utente.

È possibile impostare le richieste per accedere a domini diversi, il che può essere o non essere fattibile. I ragazzi di Yahoo hanno fatto molte ricerche in questo settore, di cui puoi leggere ( qui ). Ricorda che ogni nuovo dominio che aggiungi richiede anche una ricerca DNS. I ragazzi di YSlow raccomandano tra 2 e 4 domini per raggiungere un buon compromesso tra richieste parallele e ricerche DNS, sebbene questo si concentri sul tempo di caricamento della pagina, non sulle successive richieste AJAX.

Posso chiederti perché vuoi fare così tante richieste? Vi sono buone ragioni per cui i browser limitano il numero di richieste allo stesso dominio. Farai meglio a raggruppare le richieste se possibile.

— cbp
fonte

1

Le mie richieste XmlHttp non possono andare a domini diversi come suggerisci, a causa della stessa politica di origine. (Forse questo è un argomento per usare jsonp per aggirare questo problema.) Questa pagina è una dashboard di comando e controllo per molti computer; pertanto viene generata una richiesta per esecuzione richiesta dall'utente.

— Michael Gundlach,