it-swarm.com.de

Wie viele gleichzeitige AJAX (XmlHttpRequest) -Anfragen sind in gängigen Browsern zulässig?

In Firefox 3 lautet die Antwort 6 pro Domain: Sobald eine 7. XmlHttpRequest (auf einem beliebigen Tab) für dieselbe Domain ausgelöst wird, wird sie in die Warteschlange gestellt, bis eine der anderen 6 beendet ist.

Was sind die Zahlen für die anderen Hauptbrowser?

Gibt es auch Möglichkeiten, diese Beschränkungen zu umgehen, ohne dass meine Benutzer ihre Browsereinstellungen ändern müssen? Gibt es beispielsweise Beschränkungen für die Anzahl der JSONP-Anforderungen (bei denen die Skript-Tag-Injektion anstelle eines XmlHttpRequest-Objekts verwendet wird)?

Hintergrund: Meine Benutzer können XmlHttpRequests von einer Webseite an den Server senden und den Server auffordern, ssh-Befehle auf Remote-Hosts auszuführen. Wenn die Remote-Hosts inaktiv sind, dauert es einige Minuten, bis der Befehl ssh fehlschlägt, sodass meine Benutzer möglicherweise keine weiteren Befehle ausführen können.

350

Ein Trick, mit dem Sie die Anzahl der gleichzeitigen Verbindungen erhöhen können, ist das Hosten Ihrer Bilder von einer anderen Unterdomäne. Diese werden als separate Anfragen behandelt. Jede Domain ist auf das gleichzeitige Maximum beschränkt.

IE6, IE7 - haben ein Limit von zwei. IE8 ist 6, wenn Sie ein Breitband haben - 2 (wenn es sich um eine Einwahl handelt).

139
Bob

Die Netzwerkergebnisse unter Browserscope geben Ihnen sowohl Verbindungen pro Hostname als auch Max. Verbindungen für gängige Browser. Die Daten werden durch Ausführen von Tests an Benutzern "in freier Wildbahn" gesammelt, sodass sie auf dem neuesten Stand bleiben.

102
Kevin Hakanson

Mit IE6/IE7 kann man die Anzahl der gleichzeitigen Anfragen in der Registry optimieren. Hier erfahren Sie, wie Sie jeweils vier festlegen.

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

Ich habe gerade mit www.browserscope.org und mit IE9 und Chrome 24 können Sie 6 gleichzeitige Verbindungen zu einer einzelnen Domain und bis zu 17 zu mehreren haben.

7
xmorera

Laut IE 9 - What’s Changed? im HttpWatch-Blog hat IE9 bei VPN-Verbindungen immer noch ein Verbindungslimit von 2.

Mit einem VPN noch Clobbers IE 9 Leistung

Wir haben zuvor in IE 8 über die Reduzierung der maximalen Anzahl gleichzeitiger Verbindungen berichtet, wenn Ihr PC eine VPN-Verbindung verwendet. Dies geschah auch dann, wenn der Browserverkehr diese Verbindung nicht überschritt.

Leider ist IE 9 von VPN-Verbindungen auf die gleiche Weise betroffen:

6
Kevin Hakanson

Ich habe eine einzelne Datei geschrieben AJAX Tester. Viel Spaß !!! Nur weil ich Probleme mit meinem Hosting-Provider hatte

<?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>

Bearbeiten:
r bedeutet Reihen- und Wartezeit.
Wenn Sie zum ersten Mal die Starttaste 80 (oder eine andere Anzahl) einer gleichzeitigen Ajax-Anforderung drücken, wird dies mit Javascript gestartet, aber bekanntlich vom Browser gespoolt. Auch werden sie parallel zum Server angefordert (begrenzt auf bestimmte Anzahl, dies ist die Tatsache dieser Frage). Hier werden die Anfragen serverseitig mit einer zufälligen Verzögerung (festgelegt durch w) gelöst. Zur Startzeit wird die gesamte Zeit berechnet, die zum Lösen aller Ajax-Anrufe erforderlich ist. Wenn der Test beendet ist, können Sie sehen, ob er die Hälfte, die dritte, die vierte usw. der Gesamtzeit gedauert hat, abzüglich der Parallelität der Aufrufe an den Server. Dies ist weder streng noch genau, aber es ist schön, in Echtzeit zu sehen, wie Ajax-Anrufe ausgeführt werden (siehe das eingehende Kreuz). Und ist ein sehr einfaches, in sich geschlossenes Skript, das Ajax-Grundlagen zeigt.
Dies setzt natürlich voraus, dass die Serverseite kein zusätzliches Limit einführt.
Vorzugsweise in Verbindung mit dem Firebug Net Panel (oder dem entsprechenden Browser) verwenden.

6
Luis Siquot

Hat meinen eigenen Test geschrieben. habe den code auf stackoverflow getestet, funktioniert einwandfrei sagt mir, dass chrome/FF das kann 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();
});

es funktioniert für die meisten Websites, die zu unterschiedlichen Zeiten ein Readystate-Änderungsereignis auslösen können. (aka: Spülen)

Ich stelle auf meinem node.js-Server fest, dass ich mindestens 1025 Bytes ausgeben musste, um das Ereignis/Flush auszulösen. Andernfalls würden die Ereignisse nur alle drei Zustände gleichzeitig auslösen, wenn die Anforderung abgeschlossen ist. Hier ist mein 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);

pdate

Ich stelle fest, dass Sie jetzt bis zu 2x Anfragen haben können, wenn Sie gleichzeitig xhr und fetch api verwenden

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();
});
4
Endless

Ich glaube, es gibt eine maximale Anzahl von gleichzeitigen HTTP-Anfragen, die Browser an dieselbe Domain richten. Dies liegt in der Größenordnung von 4 bis 8 Anfragen, abhängig von den Einstellungen und dem Browser des Benutzers.

Sie können Ihre Anforderungen so einrichten, dass sie auf verschiedene Domänen verweisen, was möglicherweise möglich oder nicht möglich ist. Die Yahoo-Leute haben in diesem Bereich viel recherchiert, worüber Sie lesen können ( hier ). Denken Sie daran, dass jede neue Domäne, die Sie hinzufügen, auch eine DNS-Suche erfordert. Die YSlow-Leute empfehlen zwischen 2 und 4 Domains, um einen guten Kompromiss zwischen parallelen Anfragen und DNS-Lookups zu erzielen, obwohl sich dies auf die Ladezeit der Seite konzentriert, nicht auf nachfolgende AJAX) Anfragen.

Darf ich fragen, warum Sie so viele Anfragen stellen möchten? Es gibt gute Gründe dafür, dass die Browser die Anzahl der Anforderungen auf dieselbe Domäne beschränken. Sie sind besser dran, Anfragen zu bündeln, wenn dies möglich ist.

0
cbp