Combien de requêtes SpringBoot peut-il traiter en même temps ?

Texte

Nous savons tous que le conteneur intégré par défaut de SpringBoot est Tomcat, ce qui signifie que notre programme s'exécute réellement dans Tomcat. Il ne s’agit donc pas tant du nombre de requêtes que SpringBoot peut gérer, mais du nombre de requêtes que Tomcat peut gérer.

La configuration par défaut de Tomcat se trouve dans le fichier spring-configuration-metadata.json, et la classe de configuration correspondante est 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

Connexe au nombre de requêtes traitées Il y a quatre paramètres :

• server.tomcat.threads.min-spare

   : Le nombre minimum de threads de travail, la taille par défaut est de 10. Ce paramètre est équivalent à un travailleur à long terme. Si le nombre de requêtes simultanées n'atteint pas 10, ces threads seront utilisés en séquence pour traiter les requêtes.

  server.tomcat.threads.max

   : Le nombre maximum de threads de travail, la taille par défaut est de 200. Ce paramètre est équivalent à un travailleur temporaire. Si le nombre de requêtes simultanées est compris entre 10 et 200, ces threads de travail temporaires seront utilisés pour le traitement.

  server.tomcat.max-connections

   : Le nombre maximum de connexions, la taille par défaut est 8192. Indique le nombre maximum de requêtes que Tomcat peut traiter. Les requêtes dépassant 8 192 seront placées dans la file d'attente.

• server.tomcat.accept-count : La longueur de la file d'attente, la taille par défaut est 100.

Donnez un exemple pour illustrer la relation entre ces paramètres :

Si vous comparez Tomcat à un restaurant, alors une requête équivaut en fait à un invité. min-spare est le chef (travailleurs permanents) ; max est le nombre total de chefs (travailleurs permanents + intérimaires) ; max-connections est le nombre de places dans le restaurant ; . Les clients qui viennent ont la priorité de s'asseoir au restaurant, puis le chef commence à travailler. Si le travailleur de longue date peut terminer le travail, laissez le travailleur de longue date le faire. , laissez l'intérimaire faire le travail. Il y a 15 chefs sur la photo, et il y a 30 places dans le restaurant, c'est-à-dire que si 20 convives viennent maintenant, il y aura d'abord 5 personnes qui attendront dans le restaurant. Si 35 personnes viennent maintenant et qu’il n’y a plus de place dans le restaurant, 5 personnes seront priées de s’asseoir à la porte en premier. Si 50 personnes viennent, alors il y a 40 places dans l'hôtel + des petits bancs à la porte, donc 10 personnes partiront.

En d'autres termes, le nombre maximum de requêtes que SpringBoot peut gérer en même temps est de max-connections+accept-count. Les requêtes dépassant ce nombre seront directement rejetées.

Sur le papier, je réalise enfin que je dois procéder étape par étape.

Les résultats ci-dessus ne sont que des résultats théoriques. Utilisons maintenant un petit exemple pratique pour démontrer si tel est le cas :

Créez un projet SpringBoot et configurez ces paramètres dans application.yml, car le nombre par défaut n'est pas trop grand. facile à tester, donc la configuration est plus petite :

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

Écrivons à nouveau une interface simple :

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

Le code est très simple. Il imprime simplement le nom du fil, puis se met en veille pendant 0,5 seconde. Cela entraînera certainement l'exécution de certaines requêtes. traités immédiatement. Entrez dans la file d’attente.

Ensuite, j'ai créé un cas de test avec Apifox pour simuler 100 requêtes :

🎜🎜Observez les résultats du test : 🎜🎜🎜🎜🎜Comme le montrent les résultats, grâce à l'ensemble 🎜max-connections+accept- Le la somme du compte🎜 est de 40, donc 60 demandes seront rejetées, ce qui est conforme à nos attentes. Puisque le nombre maximum de threads est de 15, c'est-à-dire que 25 requêtes seront d'abord attendues, puis 15 seront traitées après le traitement des 15 premières, et enfin 10 seront traitées, c'est-à-dire que les 40 requêtes seront divisées en trois lots de 15, 15 et 10. traiter. 🎜🎜🎜🎜🎜Vous pouvez voir dans le journal d'impression de la console que le nombre maximum de threads est de 15, ce qui confirme également l'idée précédente. 🎜🎜🎜Pour résumer🎜 : Si le nombre de requêtes simultanées est inférieur à 🎜server.tomcat.threads.max🎜, elle sera traitée immédiatement, et l'excédent sera attendu en premier si le nombre dépasse la somme des max-. connexions et nombre d'acceptations, la partie excédentaire sera rejetée directement. 🎜🎜Extension : comment surviennent les problèmes de concurrence🎜🎜Jusqu'à présent, nous avons déterminé combien de requêtes SpringBoot peut gérer en même temps. Mais ici, je voudrais l'étendre sur la base de l'exemple ci-dessus, c'est pourquoi certaines valeurs dans des scénarios simultanés sont différentes de ce à quoi nous nous attendions ? 🎜

设想有以下场景：厨师们用一个账本记录一共做了多少道菜，每个厨师做完菜都记录一下，每次记录都是将账本上的数字先抄到草稿纸上，计算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();
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!