Wie viele Anfragen kann SpringBoot gleichzeitig verarbeiten?

Text

Wir alle wissen, dass der standardmäßig eingebettete Container von SpringBoot Tomcat ist, was bedeutet, dass unser Programm tatsächlich in Tomcat ausgeführt wird. Es kommt also nicht so sehr darauf an, wie viele Anfragen SpringBoot verarbeiten kann, sondern wie viele Anfragen Tomcat verarbeiten kann.

Die Standardkonfiguration von Tomcat befindet sich in der Datei spring-configuration-metadata.json und die entsprechende Konfigurationsklasse ist org.springframework.boot.autoconfigure.web.ServerProperties . spring-configuration-metadata.json文件中，对应的配置类则是org.springframework.boot.autoconfigure.web.ServerProperties。

和处理请求数量相关的参数有四个：

• server.tomcat.threads.min-spare：最少的工作线程数，默认大小是10。该参数相当于长期工，如果并发请求的数量达不到10，就会依次使用这几个线程去处理请求。server.tomcat.threads.max：最多的工作线程数，默认大小是200。该参数相当于临时工，如果并发请求的数量在10到200之间，就会使用这些临时工线程进行处理。server.tomcat.max-connections：最大连接数，默认大小是8192。表示Tomcat可以处理的最大请求数量，超过8192的请求就会被放入到等待队列。

• server.tomcat.accept-count：等待队列的长度，默认大小是100。

举个例子说明一下这几个参数之间的关系：

如果把Tomcat比作一家饭店的话，那么一个请求其实就相当于一位客人。min-spare就是厨师(长期工)；max是厨师总数(长期工+临时工)；max-connections就是饭店里的座位数量；accept-count是门口小板凳的数量。来的客人优先坐到饭店里面，然后厨师开始忙活，如果长期工可以干的完，就让长期工干，如果长期工干不完，就再让临时工干。图中画的厨师一共15人，饭店里有30个座位，也就是说，如果现在来了20个客人，那么就会有5个人先在饭店里等着。如果现在来了35个人，饭店里坐不下，就会让5个人先到门口坐一下。如果来了50个人，那么饭店座位+门口小板凳一共40个，所以就会有10人离开。

也就是说，SpringBoot同时所能处理的最大请求数量是max-connections+accept-count

Related Zur Anzahl der verarbeiteten Anfragen gibt es vier Parameter:

• server.tomcat.threads.min-spare

  : Die minimale Anzahl von Arbeitsthreads, die Standardgröße beträgt 10. Dieser Parameter entspricht einem Langzeit-Worker. Wenn die Anzahl gleichzeitiger Anforderungen nicht 10 erreicht, werden diese Threads nacheinander zur Verarbeitung der Anforderungen verwendet.

  server.tomcat.threads.max

  : Die maximale Anzahl von Arbeitsthreads, die Standardgröße beträgt 200. Dieser Parameter entspricht einem temporären Worker. Wenn die Anzahl gleichzeitiger Anforderungen zwischen 10 und 200 liegt, werden diese temporären Worker-Threads für die Verarbeitung verwendet.

  server.tomcat.max-connections

  : Die maximale Anzahl von Verbindungen, die Standardgröße beträgt 8192. Gibt die maximale Anzahl von Anfragen an, die Tomcat verarbeiten kann. Anfragen, die 8192 überschreiten, werden in die Warteschlange gestellt.

• server.tomcat.accept-count: Die Länge der Warteschlange, die Standardgröße beträgt 100.

Geben Sie ein Beispiel, um die Beziehung zwischen diesen Parametern zu veranschaulichen:

Wenn Sie Tomcat mit einem Restaurant vergleichen, dann entspricht eine Anfrage tatsächlich einem Gast. Min-Reserve ist der Koch (Festangestellte); Max-Verbindungen sind die Anzahl der Sitzplätze im Restaurant; . Gäste, die kommen, haben Vorrang, im Restaurant zu sitzen, und dann beginnt der Koch mit der Arbeit. Wenn der Langzeitarbeiter die Arbeit beenden kann, überlassen Sie es dem Langzeitarbeiter, die Arbeit zu beenden , lassen Sie es den Leiharbeiter machen. Auf dem Bild sind 15 Köche zu sehen und es gibt 30 Sitzplätze im Restaurant. Das heißt, wenn jetzt 20 Gäste kommen, warten zuerst 5 Personen im Restaurant. Wenn jetzt 35 Personen kommen und im Restaurant kein Platz ist, werden 5 Personen gebeten, zuerst an der Tür zu sitzen. Wenn 50 Leute kommen, dann gibt es 40 Sitzplätze im Hotel + kleine Bänke an der Tür, also gehen 10 Leute.

Mit anderen Worten, die maximale Anzahl von Anfragen, die SpringBoot gleichzeitig verarbeiten kann, beträgt max-connections+accept-count. Anfragen, die diese Anzahl überschreiten, werden direkt verworfen.

Auf dem Papier wird mir endlich klar, dass ich das Schritt für Schritt machen muss.

Die oben genannten Ergebnisse sind nur theoretische Ergebnisse. Lassen Sie uns nun anhand eines kleinen praktischen Beispiels demonstrieren, ob dies der Fall ist:

Erstellen Sie ein SpringBoot-Projekt und konfigurieren Sie diese Parameter in application.yml, da die Standardanzahl nicht zu groß ist Einfach zu testen, daher ist die Konfiguration kleiner:

server:
  tomcat:
    threads:
      # 最少线程数
      min-spare: 10
      # 最多线程数
      max: 15
    # 最大连接数
    max-connections: 30
    # 最大等待数
    accept-count: 10

Schreiben wir noch einmal eine einfache Schnittstelle:

    @GetMapping("/test")
    public Response test1(HttpServletRequest request) throws Exception {
        log.info("ip:{},线程:{}", request.getRemoteAddr(), Thread.currentThread().getName());
        Thread.sleep(500);
        return Response.buildSuccess();
    }

Der Code ist sehr einfach. Er druckt nur den Thread-Namen und ruht dann 0,5 Sekunden lang Betreten Sie die Warteschlange.

Dann habe ich mit Apifox einen Testfall erstellt, um 100 Anfragen zu simulieren:

🎜🎜Beobachten Sie die Testergebnisse: 🎜🎜🎜🎜🎜Wie aus den Ergebnissen ersichtlich ist, aufgrund des Satzes 🎜max-connections+accept- Die Die Summe der Zählungen🎜 beträgt 40, daher werden 60 Anfragen verworfen, was unseren Erwartungen entspricht. Da der maximale Thread 15 beträgt, wird zunächst auf 25 Anforderungen gewartet, dann werden 15 verarbeitet, nachdem die ersten 15 verarbeitet wurden, und schließlich werden 10 verarbeitet, d. h. die 40 Anforderungen werden in drei Stapel aufgeteilt 15, 15 und 10. befassen sich mit. 🎜🎜🎜🎜🎜Sie können dem Konsolendruckprotokoll entnehmen, dass die maximale Thread-Nummer 15 beträgt, was auch die vorherige Idee bestätigt. 🎜🎜🎜Um es zusammenzufassen🎜: Wenn die Anzahl gleichzeitiger Anfragen niedriger als 🎜server.tomcat.threads.max🎜 ist, wird sie sofort verarbeitet und der Überschuss wird zuerst abgewartet. Wenn die Anzahl die Summe der max. überschreitet. Verbindungen und Accept-Count. Der überschüssige Teil wird direkt verworfen. 🎜🎜Erweiterung: Wie Parallelitätsprobleme entstehen🎜🎜Bisher haben wir herausgefunden, wie viele Anfragen SpringBoot gleichzeitig verarbeiten kann. Aber hier möchte ich es anhand des obigen Beispiels erweitern. Warum weichen einige Werte in gleichzeitigen Szenarien von unseren Erwartungen ab? 🎜

设想有以下场景：厨师们用一个账本记录一共做了多少道菜，每个厨师做完菜都记录一下，每次记录都是将账本上的数字先抄到草稿纸上，计算x+1等于多少，然后将计算的结果写回到账本上。

Spring容器中的Bean默认是单例的，也就是说，处理请求的Controller、Service实例就只有一份。在并发场景下，将cookSum定义为全局变量，是所有线程共享的，当一个线程读到了cookSum=20，然后计算，写回前另一个线程也读到是20，两个线程都加1后写回，最终cookSum就变成了21，但是实际上应该是22，因为加了两次。

private int cookSum = 0;

@GetMapping("/test")
public Response test1(HttpServletRequest request) throws Exception {
	// 做菜。。。。。。
	cookSum += 1;
    log.info("做了{}道菜", cookSum);
    Thread.sleep(500);
	return Response.buildSuccess();
}

Das obige ist der detaillierte Inhalt vonWie viele Anfragen kann SpringBoot gleichzeitig verarbeiten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!