---
title: "Les requêtes lentes dans l'API Gateway affectent-elles les autres requêtes ? - API7.ai"
description: "APISIX ne compromet pas le temps de réponse des autres requêtes normales en raison du temps de réponse prolongé de certaines requêtes."
url: "https://api7.ai/fr/blog/slow-requests-in-api-gateway"
---

[Blog](https://api7.ai/fr/blog)

[Products](https://api7.ai/fr/category/products)[Technology](https://api7.ai/fr/category/technology)[Ecosystem](https://api7.ai/fr/category/ecosystem)[Case Study](https://api7.ai/fr/category/usercase)[Team & Community](https://api7.ai/fr/category/community)

Search

⌘ + K

[Blog](https://api7.ai/blog)

Technology

# Les requêtes lentes dans l'API Gateway affectent-elles les autres requêtes ?

December 30, 2023

[Technology](https://api7.ai/category/technology)

Une préoccupation fréquemment discutée dans le domaine des passerelles API est la capacité à gérer efficacement un nombre important de requêtes simultanées. Plus précisément, la question se pose : **les requêtes lentes augmenteront-elles de manière significative le temps de réponse des autres requêtes normales dans la passerelle API ?**

La réponse est que [APISIX](https://api7.ai/apisix) excelle dans ce domaine, démontrant que les requêtes lentes n'ont pas d'impact négatif sur les autres requêtes normales. Cependant, pour les produits de passerelle API basés sur différents langages et architectures logicielles, les performances peuvent ne pas être aussi favorables.

Divers langages de programmation présentent des degrés variables d'affinité envers les architectures logicielles concurrentes. Les premiers langages de programmation tels que C et [Fortran](https://en.wikipedia.org/wiki/Fortran), conçus principalement pour les systèmes à processeur unique, offrent un support limité pour la concurrence. Cependant, avec l'avènement des environnements multiprocesseurs et multithreads, des langages plus récents comme [Java](https://github.com/apache/apisix-java-plugin-runner) et [Python](https://github.com/apache/apisix-python-plugin-runner) intègrent des capacités de concurrence et de traitement parallèle plus robustes. Des langages comme [Go](https://github.com/apache/apisix-go-plugin-runner) ont même été conçus en tenant compte de la concurrence, intégrant étroitement leurs modèles de concurrence avec les fonctionnalités du langage. Le support de la concurrence dans un langage de programmation reflète non seulement l'environnement technologique lors de sa création, mais anticipe également ses scénarios d'application prévus.

![Coroutine et thread](https://static.api7.ai/uploads/2023/12/29/WlL3vGqI_coroutine\&thread2.jpg?imageMogr2/format/webp)

En supposant des milliers de requêtes simultanées, l'utilisation d'une architecture multithread ou multiprocessus (comme dans Java ou Python) nécessite l'allocation de milliers de threads ou processus pour gérer les contextes de requête. Ceux qui sont familiers avec la programmation informatique comprennent que, même si une majorité de threads reste inactive, le système d'exploitation consomme des ressources matérielles pour maintenir des milliers de threads ou processus. Cependant, en utilisant des coroutines (comme dans APISIX et Golang), des threads ou processus supplémentaires ne sont pas nécessaires malgré une augmentation des requêtes simultanées.

Les coroutines, threads et processus représentent tous des approches pour le multitâche, mais présentent des différences clés :

1. **Mécanisme de planification :** La planification des threads/processus est préemptive et gérée par le système d'exploitation (OS), ce qui signifie que l'OS décide quand interrompre et passer à un autre thread ou processus. Inversement, la planification des coroutines est coopérative, pilotée explicitement par les programmeurs ou les bibliothèques de langage. Les coroutines doivent explicitement abandonner le contrôle pour faciliter le passage à d'autres coroutines.
2. **Surcharge :** Les threads/processus, étant au niveau du système d'exploitation, nécessitent plus de ressources pour leur création, commutation et terminaison. Inversement, les coroutines opèrent dans l'espace utilisateur, entraînant une surcharge relativement moindre pour leur création, commutation et terminaison.
3. **Partage et synchronisation des données :** Le partage de données entre threads/processus nécessite des opérations de synchronisation complexes, telles que des verrous mutex, des verrous de lecture-écriture, des sémaphores, etc., pour éviter les conditions de course. Les coroutines, étant dans le même thread, peuvent partager directement des variables globales sans avoir besoin d'une synchronisation complexe.

![Connexion entre coroutine, thread et processus](https://static.api7.ai/uploads/2023/12/29/F6zNN9uM_img_v3_026j_6abeb19f-f406-4625-8b9a-f08e65fa321g.jpg?imageMogr2/format/webp)

Dans le monde d'APISIX, les requêtes lentes impliquent simplement d'attendre les réponses en amont, un processus limité à l'écoute des événements réseau sans entraîner de surcharge supplémentaire des ressources système. En conclusion, **APISIX ne compromet pas le temps de réponse des autres requêtes normales en raison du temps de réponse prolongé de certaines requêtes.**

Tags:

[Latency](https://api7.ai/tags/latency)

[APISIX Basics](https://api7.ai/tags/apisix-basics)

Share article link

Share

Related Posts

[![Collecte de logs simplifiée avec le plugin http-logger d'APISIX](https://static.api7.ai/uploads/2024/04/11/Zod2vE0f_http-logger-cover.png)](https://api7.ai/blog/apisix-http-logger-plugin)

## [Collecte de logs simplifiée avec le plugin http-logger d'APISIX](https://api7.ai/blog/apisix-http-logger-plugin)

[![Décoder la haute disponibilité des microservices : Exploration des stratégies de gouvernance des API avec Apache APISIX](https://static.api7.ai/uploads/2024/12/25/njZdgMBk_apisix-api-governance.png)](https://api7.ai/blog/enhance-high-availability-with-api-governance)

## [Décoder la haute disponibilité des microservices : Exploration des stratégies de gouvernance des API avec Apache APISIX](https://api7.ai/blog/enhance-high-availability-with-api-governance)

## Related Posts

[![Quoi de neuf dans ADC 0.11 et 0.12 ?](https://static.api7.ai/uploads/2025/01/21/vI79UK0t_adc-0.11-0.12.png)](https://api7.ai/fr/blog/adc-0.11-and-0.12)

Technology

August 7, 2024

#### [Quoi de neuf dans ADC 0.11 et 0.12 ?](https://api7.ai/fr/blog/adc-0.11-and-0.12)

Les versions 0.11 et 0.12 d'ADC ont optimisé la prise en charge d'Apache APISIX et de ses fonctionnalités, améliorant ainsi la gestion de la configuration et l'efficacité de GitOps.

[ADC](https://api7.ai/tags/adc)

[APISIX Basics](https://api7.ai/tags/apisix-basics)

[![3 conseils pour déployer APISIX dans Kubernetes (Partie 2)](https://static.api7.ai/uploads/2024/05/07/5oXyr34X_deploy-apisix-in-k8s.png)](https://api7.ai/fr/blog/3-tips-for-deploying-apisix-in-k8s-2)

Technology

May 7, 2024

#### [3 conseils pour déployer APISIX dans Kubernetes (Partie 2)](https://api7.ai/fr/blog/3-tips-for-deploying-apisix-in-k8s-2)

Découvrez comment optimiser le déploiement d'Apache APISIX dans Kubernetes, en améliorant la stabilité et les performances des services API grâce aux contrôles de santé et à la surveillance.

[Kubernetes](https://api7.ai/tags/kubernetes)

[APISIX Basics](https://api7.ai/tags/apisix-basics)

[![Test régulier des API : Assurer la stabilité et l'efficacité de l'API Gateway](https://static.api7.ai/uploads/2024/04/12/KxwkXy3P_api-testing.png)](https://api7.ai/fr/blog/best-practices-for-api-testing)

Technology

April 12, 2024

#### [Test régulier des API : Assurer la stabilité et l'efficacité de l'API Gateway](https://api7.ai/fr/blog/best-practices-for-api-testing)

À l'ère numérique, les APIs jouent un rôle crucial, mais elles nécessitent également une maintenance et des vérifications pour garantir leur stabilité et leur sécurité. Découvrez l'importance et les étapes des tests d'API pour améliorer les performances et assurer la sécurité.

[APISIX Basics](https://api7.ai/tags/apisix-basics)
