CATALOGUE Code & Data Formation Python Maîtriser Python - Techniques avancées Comprendre le Threading en Python et l'Impact du Global Interpreter Lock (GIL)

Comprendre le Threading en Python et l'Impact du Global Interpreter Lock (GIL)

Threading
Vidéo non disponible ! Réessayez plus tard
Cette vidéo fait partie de la formation
Maîtriser Python - Techniques avancées
Revoir le teaser Je m'abonne
5,0
Transcription
Cette leçon fait partie de la formation
99,00€ Je commande
Formation incluse dans l'abonnement Elephorm Je m'abonne à Elephorm
DescriptionProgrammeAvis
5,0
Cette leçon fait partie de la formation
99,00€ Je commande
Formation incluse dans l'abonnement Elephorm Je m'abonne à Elephorm

Exemples et Applications Pratiques de Threading en Python

Objectifs

Comprendre le fonctionnement du threading en Python et son impact sur les performances
Apprendre à utiliser les threads pour des tâches non bloquantes
Découvrir comment le GIL affecte le threading en Python

Résumé

Découvrez pourquoi le threading en Python fonctionne différemment des autres langages et comment utiliser les threads pour des tâches non bloquantes.

Description

En Python, le threading fonctionne différemment des autres langages de programmation en raison du Global Interpreter Lock (GIL). Ce verrou global empêche les threads d'être exécutés sur plusieurs CPU, limitant ainsi le véritable parallélisme. Cependant, les threads peuvent être utilisés pour éviter les blocages dans les tâches longues, comme les interfaces graphiques, où une tâche intensive peut bloquer l'interface utilisateur.

Nous explorons ici un exemple concret illustrant pourquoi le threading ne peut pas accélérer le traitement des programmes Python pour des tâches intensives en CPU. Nous détaillons ensuite une solution pratique pour utiliser les threads afin de maintenir la réactivité de l'interface utilisateur en Python.

En utilisant deux gros fichiers à zipper en parallèle, nous démontrons que le threading peut même ralentir le programme. Toutefois, pour des cas d'utilisation non bloquante, surtout dans les interfaces graphiques, le threading est extrêmement utile.

Apprenez également à gérer les threads de manière plus efficace avec le ThreadPoolExecutor, une approche qui permet de distribuer le travail entre plusieurs threads sans avoir à gérer la création et la destruction de chaque thread individuellement.

Voir plus

Questions fréquentes

Qu'est-ce que le GIL en Python ?
Le Global Interpreter Lock (GIL) est un mécanisme dans le principal interpréteur Python (CPython) qui empêche l'exécution simultanée de plusieurs threads sur plusieurs processeurs pour protéger les accès aux objets Python.
Pourquoi les threads en Python ne permettent-ils pas d'accélérer les tâches CPU intensives ?
Les threads en Python ne peuvent pas accélérer les tâches CPU intensives à cause du GIL, qui empêche plusieurs threads d'exécuter des bytecodes Python en même temps sur plusieurs CPU.
Quels sont les principaux usages des threads en Python ?
Les threads en Python sont principalement utilisés pour des tâches non bloquantes, telles que la gestion des interfaces graphiques ou des opérations I/O, plutôt que pour des calculs intensifs en CPU.

Programme détaillé

3 commentaires
5,0
3 votes
5
4
3
2
1
xavier.leleu
Il y a 3 mois
Bonjour,
Les thèmes variés agrémentés d'exemples simples et clairs enrichissent toutes les notions exposées de façon particulièrement pédagogique. 👍
L'approche didactique m'a permis de beaucoup mieux comprendre tout un tas de concepts plus ou moins bien assimilés auparavant avec une vue d'ensemble nettement plus limpide aujourd'hui. 🤓
Merci pour cette belle prestation. 🙏
michelkreutner
Il y a 1 an
Les explications sont claires et concises. Ce cours sur l'utilisation avancée de Python est tres intéressant. Il vous apportera des connaissances que vous pourrez ensuite approfondir.
Je suis vraiment tres satisfait par cette première formation suivie sur Python.
yvan.vogel
Il y a 3 ans
Hello, sur la video autour de asyncio, vous utilisez python 2.7.12. J'utilise python 3.10, aussi je souhaite faire partager mon code (qui fonctionne) selon ma vision et compréhension sur le sujet d'étude que vous avez proposé. Yvan Vogel.

#CODE en python 3.10.0 64 bits (VScode 1.62.3)
import datetime
import asyncio
import aiohttp
import requests


# ----------------------------------------------------------------------------------------------------------------------------
def req_bloquante(num):
print(f"Get {num}")
uid = requests.get("https://httpbin.org/uuid").json()["uuid"]
print(f"Res {num}: {uid}")


def faire_toutes_les_requetes():
for x in range(51):
req_bloquante(x)


print("=====> ### Bloquant : ")
start = datetime.datetime.now()
faire_toutes_les_requetes()
exec_time = (datetime.datetime.now() - start).seconds
print(f"Downloading all take {exec_time} seconds\n")

# ----------------------------------------------------------------------------------------------------------------------------


async def requeteSansBloquer(semaphore, num, session):
print(f"Get {num}")
# await semaphore.acquire() # putting this await semaphore commande the Res is ordering but process very slow ~60 sec
async with session.get("https://httpbin.org/uuid") as response:
uid = (await response.json())["uuid"]
# await asyncio.sleep(delay=3) #delay = number of seconds
# semaphore.release()
print(f"Res {num}: {uid}")
# return uid # ?


async def main():
semaphore = asyncio.Semaphore(value=1)
tasks = []
async with aiohttp.ClientSession(
loop=loop, connector=aiohttp.TCPConnector(ssl=False)
) as session:
for x in range(51):
tasks.append(requeteSansBloquer(semaphore, x, session))
await asyncio.gather(*tasks)
print("This is after the loop...")


if __name__ == "__main__":
print("=====> ### Non Bloquant : ")
start = datetime.datetime.now()
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
exec_time = (datetime.datetime.now() - start).microseconds
print(f"Downloading all take {exec_time} micro seconds\n")