{"id":671429,"date":"2025-12-29T10:40:02","date_gmt":"2025-12-29T09:40:02","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=pycharm&p=671429"},"modified":"2025-12-29T10:40:05","modified_gmt":"2025-12-29T09:40:05","slug":"etre-plus-rapide-avec-python-concurrence-avec-async-await-et-threading","status":"publish","type":"pycharm","link":"https:\/\/blog.jetbrains.com\/fr\/pycharm\/2025\/12\/etre-plus-rapide-avec-python-concurrence-avec-async-await-et-threading\/","title":{"rendered":"\u00catre plus rapide avec Python\u00a0: concurrence avec async\/await et threading"},"content":{"rendered":"
\"Faster<\/figure>\n

Si vous programmez avec Python depuis un certain temps, en particulier si vous avez utilis\u00e9 des frameworks et des biblioth\u00e8ques tels que FastAPI et discord.py, alors vous avez probablement utilis\u00e9 async\/await<\/code> ou asyncio<\/code>. Vous avez peut-\u00eatre entendu dire que \u00ab le multithreading en Python n\u2019est pas r\u00e9el \u00bb, ou vous connaissez peut-\u00eatre le fameux (ou tristement c\u00e9l\u00e8bre) GIL de Python. \u00c9tant donn\u00e9 ce scepticisme \u00e0 l’\u00e9gard du multithreading en Python, vous pourriez vous demander en quoi async\/await<\/code> et le multithreading diff\u00e8rent r\u00e9ellement, notamment dans le contexte de la programmation Python. Si c’est le cas, cet article est fait pour vous\u00a0!<\/p>\n

Qu’est-ce que le multithreading\u00a0?<\/h2>\n

En programmation, le multithreading d\u00e9signe la capacit\u00e9 d’un programme \u00e0 ex\u00e9cuter plusieurs t\u00e2ches s\u00e9quentielles (appel\u00e9es threads) simultan\u00e9ment. Ces threads peuvent s’ex\u00e9cuter sur un seul c\u0153ur de processeur ou sur plusieurs c\u0153urs. Cependant, en Python, le multithreading n’est g\u00e9r\u00e9 que sur un seul c\u0153ur en raison des limitations du Global Interpreter Lock (GIL). L’exception est Python nogil (\u00e9galement appel\u00e9 sans thread), qui supprime le GIL et sera abord\u00e9 dans la deuxi\u00e8me partie de cette s\u00e9rie d’articles. Pour cet article, nous supposerons que le GIL est toujours pr\u00e9sent.<\/p>\n

Qu’est-ce que la concurrence\u00a0?<\/h2>\n

En programmation, la concurrence signifie que l’ordinateur fait plusieurs choses \u00e0 la fois, ou semble faire plusieurs choses \u00e0 la fois, m\u00eame si les diff\u00e9rentes t\u00e2ches sont ex\u00e9cut\u00e9es sur un seul processeur. En g\u00e9rant les ressources et les interactions entre les diff\u00e9rentes parties d’un programme, diff\u00e9rentes t\u00e2ches sont autoris\u00e9es \u00e0 progresser ind\u00e9pendamment et sur des plages de temps qui se chevauchent.<\/p>\n

asyncio<\/code> et threading<\/code> pr\u00e9sentent toutes deux une capacit\u00e9 de concurrence en Python<\/h3>\n

En gros, les biblioth\u00e8ques Python asyncio<\/code> et threading<\/code> prennent en charge la concurrence. Cependant, vos processeurs ne font pas plusieurs choses exactement en m\u00eame temps. On dirait seulement que c’est le cas.<\/p>\n

Imaginez que vous organisez un d\u00eener avec plusieurs plats pour des invit\u00e9s. Certains plats prennent du temps \u00e0 pr\u00e9parer, par exemple, la tarte qui doit \u00eatre cuite au four ou la soupe qui doit mijoter sur la cuisini\u00e8re. En attendant qu’ils soient pr\u00eats, nous ne nous contentons pas d’attendre. Nous faisons autre chose entre-temps. C’est un peu pareil pour la concurrence en Python. Parfois, votre processus Python attend que quelque chose soit fait. Par exemple, certains processus d’entr\u00e9e\/sortie (I\/O) sont g\u00e9r\u00e9s par le syst\u00e8me d’exploitation, et pendant ce temps, le processus Python est simplement en attente. Dans ce cas, nous pouvons utiliser async pour laisser un autre processus Python s’ex\u00e9cuter pendant cette attente.<\/p>\n

\"Multithreading<\/figure>\n

La diff\u00e9rence est qui a le contr\u00f4le<\/h3>\n

Si asyncio<\/code> et threading<\/code> permettent toutes les deux la concurrence, quelle est la diff\u00e9rence entre elles\u00a0? Eh bien, la principale diff\u00e9rence porte sur qui d\u00e9cide quel processus s’ex\u00e9cute et quand. Pour async\/await<\/code>, l’approche est parfois appel\u00e9e concurrence coop\u00e9rative. Une coroutine ou un objet Future peut passer le contr\u00f4le \u00e0 une autre coroutine ou un autre Future permettant ainsi \u00e0 un autre processus de s’ex\u00e9cuter. D’un autre c\u00f4t\u00e9, avec threading<\/code>, c’est le gestionnaire du syst\u00e8me d’exploitation qui d\u00e9cide quel processus s’ex\u00e9cute.<\/p>\n

La concurrence coop\u00e9rative est comme une r\u00e9union dans laquelle un micro passe dans l’assembl\u00e9e pour que les gens s’expriment. La personne qui a le micro peut parler, et quand elle a termin\u00e9 ou n’a plus rien d’autre \u00e0 dire, elle passe le micro \u00e0 la personne suivante. En revanche, le multithreading est une r\u00e9union dans laquelle un pr\u00e9sident d\u00e9termine qui a la parole \u00e0 un moment donn\u00e9.\u00a0<\/p>\n

\u00c9crire du code concurrent en Python<\/h2>\n

Voyons comment fonctionne la concurrence en Python en \u00e9crivant un exemple de code. Nous allons cr\u00e9er une simulation de restauration rapide en utilisant asyncio<\/code> et threading<\/code>.<\/p>\n

Comment fonctionne async\/await<\/code> en Python\u00a0?<\/h3>\n

Le paquet asyncio<\/code> a \u00e9t\u00e9 introduit dans Python 3.4, tandis que les mots-cl\u00e9s async<\/code> et await<\/code> ont \u00e9t\u00e9 introduits dans Python\u00a03.5. L’un des principaux \u00e9l\u00e9ments rendant async\/await<\/code> possible est l’utilisation de coroutines. Les coroutines en Python sont en fait des g\u00e9n\u00e9rateurs repens\u00e9s afin de pouvoir faire une pause et de revenir \u00e0 la fonction principale.<\/p>\n

Imaginez maintenant un restaurant de burgers dans lequel un seul membre du personnel travaille. Les commandes sont pr\u00e9par\u00e9es selon la m\u00e9thode premier arriv\u00e9, premier servi, et aucune op\u00e9ration asynchrone ne peut \u00eatre effectu\u00e9e\u00a0:<\/p>\n

import time\n\n\ndef make_burger(order_num):\n    print(f\"Preparing burger #{order_num}...\")\n    time.sleep(5) # time for making the burger\n    print(f\"Burger made #{order_num}\")\n\n\ndef main():\n    for i in range(3):\n        make_burger(i)\n\n\nif __name__ == \"__main__\":\n    s = time.perf_counter()\n    main()\n    elapsed = time.perf_counter() - s\n    print(f\"Orders completed in {elapsed:0.2f} seconds.\")\n<\/pre>\n
Cela prendra un certain temps\u00a0:<\/p>\n
Preparing burger #0...\n\nBurger made #0\n\nPreparing burger #1...\n\nBurger made #1\n\nPreparing burger #2...\n\nBurger made #2\n\nOrders completed in 15.01 seconds.<\/pre>\n
Maintenant, imaginez que le restaurant embauche plus de personnel, afin de pouvoir effectuer des t\u00e2ches simultan\u00e9ment\u00a0:<\/p>\n
import asyncio\n\nimport time\n\nasync def make_burger(order_num):\n\n\u00a0\u00a0\u00a0\u00a0print(f\"Preparing burger #{order_num}...\")\n\n\u00a0\u00a0\u00a0\u00a0await asyncio.sleep(5) # time for making the burger\n\n\u00a0\u00a0\u00a0\u00a0print(f\"Burger made #{order_num}\")\n\nasync def main():\n\n\u00a0\u00a0\u00a0\u00a0order_queue = []\n\n\u00a0\u00a0\u00a0\u00a0for i in range(3):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0order_queue.append(make_burger(i))\n\n\u00a0\u00a0\u00a0\u00a0await asyncio.gather(*(order_queue))\n\nif __name__ == \"__main__\":\n\n\u00a0\u00a0\u00a0\u00a0s = time.perf_counter()\n\n\u00a0\u00a0\u00a0\u00a0asyncio.run(main())\n\n\u00a0\u00a0\u00a0\u00a0elapsed = time.perf_counter() - s\n\n\u00a0\u00a0\u00a0\u00a0print(f\"Orders completed in {elapsed:0.2f} seconds.\")<\/pre>\n
Nous voyons la diff\u00e9rence entre les deux\u00a0:<\/p>\n
Preparing burger #0...\n\nPreparing burger #1...\n\nPreparing burger #2...\n\nBurger made #0\n\nBurger made #1\n\nBurger made #2\n\nOrders completed in 5.00 seconds.<\/pre>\n
En utilisant les fonctions fournies par asyncio<\/code>, comme run<\/code> et gather<\/code>, et les mots-cl\u00e9s async<\/code> et await<\/code>, nous avons cr\u00e9\u00e9 des coroutines capables de faire des burgers simultan\u00e9ment.<\/p>\n
Allons maintenant plus loin pour cr\u00e9er une simulation plus compliqu\u00e9e. Imaginez que nous n’avons que deux employ\u00e9s et que nous ne pouvons faire que deux burgers \u00e0 la fois.<\/p>\n
import asyncio\n\nimport time\n\norder_queue = asyncio.Queue()\n\ndef take_order():\n\n\u00a0\u00a0for i in range(3):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0order_queue.put_nowait(make_burger(i))\n\nasync def make_burger(order_num):\n\n\u00a0\u00a0print(f\"Preparing burger #{order_num}...\")\n\n\u00a0\u00a0await asyncio.sleep(5)\u00a0 # time for making the burger\n\n\u00a0\u00a0print(f\"Burger made #{order_num}\")\n\nclass Staff:\n\n\u00a0\u00a0def __init__(self, name):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0self.name = name\n\n\u00a0\u00a0async def working(self):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0while order_queue.qsize() > 0:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"{self.name} is working...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task = await order_queue.get()\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await task\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"{self.name} finished a task...\")\n\nasync def main():\n\n\u00a0\u00a0staff1 = Staff(name=\"John\")\n\n\u00a0\u00a0staff2 = Staff(name=\"Jane\")\n\n\u00a0\u00a0take_order()\n\n\u00a0\u00a0await asyncio.gather(staff1.working(), staff2.working())\n\nif __name__ == \"__main__\":\n\n\u00a0\u00a0s = time.perf_counter()\n\n\u00a0\u00a0asyncio.run(main())\n\n\u00a0\u00a0elapsed = time.perf_counter() - s\n\n\u00a0\u00a0print(f\"Orders completed in {elapsed:0.2f} seconds.\")<\/pre>\n
Ici, nous utiliserons une file d’attente pour stocker les t\u00e2ches, et le personnel les r\u00e9cup\u00e9rera.<\/p>\n
John is working...\n\nPreparing burger #0...\n\nJane is working...\n\nPreparing burger #1...\n\nBurger made #0\n\nJohn finished a task...\n\nJohn is working...\n\nPreparing burger #2...\n\nBurger made #1\n\nJane finished a task...\n\nBurger made #2\n\nJohn finished a task...\n\nOrders completed in 10.00 seconds.<\/pre>\n
Dans cet exemple, nous utilisons asyncio.Queue<\/code> pour stocker les t\u00e2ches, mais ce sera plus utile si nous avons plusieurs types de t\u00e2ches, comme dans l’exemple suivant.<\/p>\n
import asyncio\n\nimport time\n\ntask_queue = asyncio.Queue()\n\norder_num = 0\n\nasync def take_order():\n\n\u00a0\u00a0\u00a0global order_num\n\n\u00a0\u00a0\u00a0order_num += 1\n\n\u00a0\u00a0\u00a0print(f\"Order burger and fries for order #{order_num:04d}:\")\n\n\u00a0\u00a0\u00a0burger_num = input(\"Number of burgers:\")\n\n\u00a0\u00a0\u00a0for i in range(int(burger_num)):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await task_queue.put(make_burger(f\"{order_num:04d}-burger{i:02d}\"))\n\n\u00a0\u00a0\u00a0fries_num = input(\"Number of fries:\")\n\n\u00a0\u00a0\u00a0for i in range(int(fries_num)):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await task_queue.put(make_fries(f\"{order_num:04d}-fries{i:02d}\"))\n\n\u00a0\u00a0\u00a0print(f\"Order #{order_num:04d} queued.\")\n\n\u00a0\u00a0\u00a0await task_queue.put(take_order())\n\nasync def make_burger(order_num):\n\n\u00a0\u00a0\u00a0print(f\"Preparing burger #{order_num}...\")\n\n\u00a0\u00a0\u00a0await asyncio.sleep(5)\u00a0 # time for making the burger\n\n\u00a0\u00a0\u00a0print(f\"Burger made #{order_num}\")\n\nasync def make_fries(order_num):\n\n\u00a0\u00a0\u00a0print(f\"Preparing fries #{order_num}...\")\n\n\u00a0\u00a0\u00a0await asyncio.sleep(2)\u00a0 # time for making fries\n\n\u00a0\u00a0\u00a0print(f\"Fries made #{order_num}\")\n\nclass Staff:\n\n\u00a0\u00a0\u00a0def __init__(self, name):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0self.name = name\n\n\u00a0\u00a0\u00a0async def working(self):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0while True:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if task_queue.qsize() > 0:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"{self.name} is working...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task = await task_queue.get()\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await task\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"{self.name} finish task...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0else:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await asyncio.sleep(1) #rest\n\nasync def main():\n\n\u00a0\u00a0\u00a0task_queue.put_nowait(take_order())\n\n\u00a0\u00a0\u00a0staff1 = Staff(name=\"John\")\n\n\u00a0\u00a0\u00a0staff2 = Staff(name=\"Jane\")\n\n\u00a0\u00a0\u00a0await asyncio.gather(staff1.working(), staff2.working())\n\nif __name__ == \"__main__\":\n\n\u00a0\u00a0\u00a0s = time.perf_counter()\n\n\u00a0\u00a0\u00a0asyncio.run(main())\n\n\u00a0\u00a0\u00a0elapsed = time.perf_counter() - s\n\n\u00a0\u00a0\u00a0print(f\"Orders completed in {elapsed:0.2f} seconds.\")<\/pre>\n
Dans cet exemple, il y a plusieurs t\u00e2ches, notamment la pr\u00e9paration des frites, qui prend moins de temps, et la prise de commandes, qui implique d’obtenir des informations de l’utilisateur.\u00a0<\/p>\n
Notez que le programme s’arr\u00eate pour attendre l’entr\u00e9e de l’utilisateur, et m\u00eame les autres membres du personnel (qui ne prennent pas la commande) cessent de travailler en arri\u00e8re-plan. Ceci est d\u00fb au fait que la fonction input<\/code> n’est pas asynchrone et n’est donc pas attendue. N’oubliez pas que le contr\u00f4le dans le code asynchrone n’est lib\u00e9r\u00e9 que lorsqu’il est attendu. Pour r\u00e9soudre ce probl\u00e8me, nous pouvons remplacer\u00a0:<\/p>\n
input(\"Number of burgers:\")<\/pre>\n
Par\u00a0<\/p>\n
await asyncio.to_thread(input, \"Number of burgers:\")<\/pre>\n
Et nous faisons de m\u00eame pour les frites\u00a0; regardez le code ci-dessous. Notez que maintenant le programme fonctionne dans une boucle infinie. Si nous devons l’arr\u00eater, nous pouvons d\u00e9lib\u00e9r\u00e9ment interrompre le programme avec une entr\u00e9e invalide.<\/p>\n
import asyncio\n\nimport time\n\ntask_queue = asyncio.Queue()\n\norder_num = 0\n\nasync def take_order():\n\n\u00a0\u00a0\u00a0global order_num\n\n\u00a0\u00a0\u00a0order_num += 1\n\n\u00a0\u00a0\u00a0print(f\"Order burger and fries for order #{order_num:04d}:\")\n\n\u00a0\u00a0\u00a0burger_num = await asyncio.to_thread(input, \"Number of burgers:\")\n\n\u00a0\u00a0\u00a0for i in range(int(burger_num)):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await task_queue.put(make_burger(f\"{order_num:04d}-burger{i:02d}\"))\n\n\u00a0\u00a0\u00a0fries_num = await asyncio.to_thread(input, \"Number of fries:\")\n\n\u00a0\u00a0\u00a0for i in range(int(fries_num)):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await task_queue.put(make_fries(f\"{order_num:04d}-fries{i:02d}\"))\n\n\u00a0\u00a0\u00a0print(f\"Order #{order_num:04d} queued.\")\n\n\u00a0\u00a0\u00a0await task_queue.put(take_order())\n\nasync def make_burger(order_num):\n\n\u00a0\u00a0\u00a0print(f\"Preparing burger #{order_num}...\")\n\n\u00a0\u00a0\u00a0await asyncio.sleep(5)\u00a0 # time for making the burger\n\n\u00a0\u00a0\u00a0print(f\"Burger made #{order_num}\")\n\nasync def make_fries(order_num):\n\n\u00a0\u00a0\u00a0print(f\"Preparing fries #{order_num}...\")\n\n\u00a0\u00a0\u00a0await asyncio.sleep(2)\u00a0 # time for making fries\n\n\u00a0\u00a0\u00a0print(f\"Fries made #{order_num}\")\n\nclass Staff:\n\n\u00a0\u00a0\u00a0def __init__(self, name):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0self.name = name\n\n\u00a0\u00a0\u00a0async def working(self):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0while True:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if task_queue.qsize() > 0:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"{self.name} is working...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task = await task_queue.get()\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await task\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"{self.name} finish task...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0else:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await asyncio.sleep(1) #rest\n\nasync def main():\n\n\u00a0\u00a0\u00a0task_queue.put_nowait(take_order())\n\n\u00a0\u00a0\u00a0staff1 = Staff(name=\"John\")\n\n\u00a0\u00a0\u00a0staff2 = Staff(name=\"Jane\")\n\n\u00a0\u00a0\u00a0await asyncio.gather(staff1.working(), staff2.working())\n\nif __name__ == \"__main__\":\n\n\u00a0\u00a0\u00a0s = time.perf_counter()\n\n\u00a0\u00a0\u00a0asyncio.run(main())\n\n\u00a0\u00a0\u00a0elapsed = time.perf_counter() - s\n\n\u00a0\u00a0\u00a0print(f\"Orders completed in {elapsed:0.2f} seconds.\")<\/pre>\n
En utilisant asyncio.to_thread<\/code>, nous avons plac\u00e9 la fonction input<\/code> dans un thread s\u00e9par\u00e9 (voir cette r\u00e9f\u00e9rence<\/a>). Notez toutefois que cette astuce ne d\u00e9bloque les t\u00e2ches associ\u00e9es aux I\/O que si le GIL Python est pr\u00e9sent.<\/p>\n
Si vous ex\u00e9cutez le code ci-dessus, vous pouvez \u00e9galement voir que les I\/O standard du terminal sont m\u00e9lang\u00e9es. Les I\/O de l’utilisateur et l’enregistrement de ce qui se passe doivent \u00eatre s\u00e9par\u00e9s. Nous pouvons enregistrer ces informations dans un fichier journal pour les consulter plus tard.\u00a0<\/p>\n
import asyncio\n\nimport logging\n\nimport time\n\nlogger = logging.getLogger(__name__)\n\nlogging.basicConfig(filename='pyburger.log', level=logging.INFO)\n\ntask_queue = asyncio.Queue()\n\norder_num = 0\n\nclosing = False\n\nasync def take_order():\n\n\u00a0\u00a0\u00a0global order_num, closing\n\n\u00a0\u00a0\u00a0try:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0order_num += 1\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(f\"Taking Order #{order_num:04d}...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"Order burger and fries for order #{order_num:04d}:\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0burger_num = await asyncio.to_thread(input, \"Number of burgers:\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0for i in range(int(burger_num)):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await task_queue.put(make_burger(f\"{order_num:04d}-burger{i:02d}\"))\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0fries_num = await asyncio.to_thread(input, \"Number of fries:\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0for i in range(int(fries_num)):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await task_queue.put(make_fries(f\"{order_num:04d}-fries{i:02d}\"))\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(f\"Order #{order_num:04d} queued.\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"Order #{order_num:04d} queued, please wait.\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await task_queue.put(take_order())\n\n\u00a0\u00a0\u00a0except ValueError:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(\"Goodbye!\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(\"Closing down... stop taking orders and finish all tasks.\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0closing = True\n\nasync def make_burger(order_num):\n\n\u00a0\u00a0\u00a0logger.info(f\"Preparing burger #{order_num}...\")\n\n\u00a0\u00a0\u00a0await asyncio.sleep(5)\u00a0 # time for making the burger\n\n\u00a0\u00a0\u00a0logger.info(f\"Burger made #{order_num}\")\n\nasync def make_fries(order_num):\n\n\u00a0\u00a0\u00a0logger.info(f\"Preparing fries #{order_num}...\")\n\n\u00a0\u00a0\u00a0await asyncio.sleep(2)\u00a0 # time for making fries\n\n\u00a0\u00a0\u00a0logger.info(f\"Fries made #{order_num}\")\n\nclass Staff:\n\n\u00a0\u00a0\u00a0def __init__(self, name):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0self.name = name\n\n\u00a0\u00a0\u00a0async def working(self):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0while True:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if task_queue.qsize() > 0:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(f\"{self.name} is working...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task = await task_queue.get()\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await task\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task_queue.task_done()\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(f\"{self.name} finish task.\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0elif closing:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0else:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0await asyncio.sleep(1) #rest\n\nasync def main():\n\n\u00a0\u00a0\u00a0global task_queue\n\n\u00a0\u00a0\u00a0task_queue.put_nowait(take_order())\n\n\u00a0\u00a0\u00a0staff1 = Staff(name=\"John\")\n\n\u00a0\u00a0\u00a0staff2 = Staff(name=\"Jane\")\n\n\u00a0\u00a0\u00a0print(\"Welcome to Pyburger!\")\n\n\u00a0\u00a0\u00a0logger.info(\"Ready for business!\")\n\n\u00a0\u00a0\u00a0await asyncio.gather(staff1.working(), staff2.working())\n\n\u00a0\u00a0\u00a0logger.info(\"All tasks finished. Closing now.\")\n\nif __name__ == \"__main__\":\n\n\u00a0\u00a0\u00a0s = time.perf_counter()\n\n\u00a0\u00a0\u00a0asyncio.run(main())\n\n\u00a0\u00a0\u00a0elapsed = time.perf_counter() - s\n\n\u00a0\u00a0\u00a0logger.info(f\"Orders completed in {elapsed:0.2f} seconds.\")<\/pre>\n
Dans ce dernier bloc de code, nous avons consign\u00e9 les informations de simulation dans pyburger.log<\/code> et r\u00e9serv\u00e9 le terminal pour les messages destin\u00e9s aux clients. Nous d\u00e9tectons \u00e9galement les entr\u00e9es non valides pendant le processus de commande et basculons un indicateur closing<\/code> sur True<\/code> si l’entr\u00e9e n’est pas valide, en supposant que l’utilisateur souhaite quitter. Une fois que l’indicateur closing<\/code> est d\u00e9fini sur True<\/code>, l’employ\u00e9 passe \u00e0 return<\/code>, ce qui met fin \u00e0 la boucle while<\/code> infinie de la coroutine.<\/p>\n
Comment fonctionne le threading<\/code> en Python\u00a0?<\/h3>\n
Dans l’exemple ci-dessus, nous pla\u00e7ons une t\u00e2che associ\u00e9e aux I\/O dans un autre thread. Vous vous demandez peut-\u00eatre si nous pouvons placer toutes les t\u00e2ches dans des threads s\u00e9par\u00e9s et les laisser s’ex\u00e9cuter simultan\u00e9ment. Essayons d’utiliser threading<\/code> au lieu d’asyncio<\/code>.<\/p>\n
Prenez le code que nous avons, comme indiqu\u00e9 ci-dessous, o\u00f9 nous cr\u00e9ons des burgers simultan\u00e9ment sans avoir mis en place aucune limitation\u00a0:<\/p>\n
import asyncio\n\nimport time\n\nasync def make_burger(order_num):\n\n\u00a0\u00a0\u00a0\u00a0print(f\"Preparing burger #{order_num}...\")\n\n\u00a0\u00a0\u00a0\u00a0await asyncio.sleep(5) # time for making the burger\n\n\u00a0\u00a0\u00a0\u00a0print(f\"Burger made #{order_num}\")\n\nasync def main():\n\n\u00a0\u00a0\u00a0\u00a0order_queue = []\n\n\u00a0\u00a0\u00a0\u00a0for i in range(3):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0order_queue.append(make_burger(i))\n\n\u00a0\u00a0\u00a0\u00a0await asyncio.gather(*(order_queue))\n\nif __name__ == \"__main__\":\n\n\u00a0\u00a0\u00a0\u00a0s = time.perf_counter()\n\n\u00a0\u00a0\u00a0\u00a0asyncio.run(main())\n\n\u00a0\u00a0\u00a0\u00a0elapsed = time.perf_counter() - s\n\n\u00a0\u00a0\u00a0\u00a0print(f\"Orders completed in {elapsed:0.2f} seconds.\")\n\n```\n\nInstead of creating async coroutines to make the burgers, we can just send functions down different threads like this:\n\n```\n\nimport threading\n\nimport time\n\ndef make_burger(order_num):\n\n\u00a0\u00a0\u00a0print(f\"Preparing burger #{order_num}...\")\n\n\u00a0\u00a0\u00a0time.sleep(5) # time for making the burger\n\n\u00a0\u00a0\u00a0print(f\"Burger made #{order_num}\")\n\ndef main():\n\n\u00a0\u00a0\u00a0order_queue = []\n\n\u00a0\u00a0\u00a0for i in range(3):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task = threading.Thread(target=make_burger, args=(i,))\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0order_queue.append(task)\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task.start()\n\n\u00a0\u00a0\u00a0for task in order_queue:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task.join()\n\nif __name__ == \"__main__\":\n\n\u00a0\u00a0\u00a0s = time.perf_counter()\n\n\u00a0\u00a0\u00a0main()\n\n\u00a0\u00a0\u00a0elapsed = time.perf_counter() - s\n\n\u00a0\u00a0\u00a0print(f\"Orders completed in {elapsed:0.2f} seconds.\")<\/pre>\n
Dans la premi\u00e8re boucle for<\/code> dans main<\/code>, les t\u00e2ches sont cr\u00e9\u00e9es dans diff\u00e9rents threads et peuvent d\u00e9marrer rapidement. La deuxi\u00e8me boucle for<\/code> s’assure que tous les burgers sont faits avant que le programme ne passe \u00e0 la suite (c’est-\u00e0-dire avant qu’il ne revienne \u00e0 main<\/code>).<\/p>\n
C’est plus compliqu\u00e9 lorsque nous n’avons que deux employ\u00e9s. Chaque membre du personnel est repr\u00e9sent\u00e9 par un thread, et ils prennent des t\u00e2ches \u00e0 partir d’une liste normale o\u00f9 elles sont toutes stock\u00e9es.<\/p>\n
import threading\n\nimport time\n\norder_queue = []\n\ndef take_order():\n\n\u00a0\u00a0\u00a0for i in range(3):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0order_queue.append(make_burger(i))\n\ndef make_burger(order_num):\n\n\u00a0\u00a0\u00a0def making_burger():\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"Preparing burger #{order_num}...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0time.sleep(5)\u00a0 # time for making the burger\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"Burger made #{order_num}\")\n\n\u00a0\u00a0\u00a0return making_burger\n\ndef working():\n\n\u00a0\u00a0\u00a0\u00a0\u00a0while len(order_queue) > 0:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"{threading.current_thread().name} is working...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task = order_queue.pop(0)\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task()\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"{threading.current_thread().name} finish task...\")\n\ndef main():\n\n\u00a0\u00a0\u00a0take_order()\n\n\u00a0\u00a0\u00a0staff1 = threading.Thread(target=working, name=\"John\")\n\n\u00a0\u00a0\u00a0staff1.start()\n\n\u00a0\u00a0\u00a0staff2 = threading.Thread(target=working, name=\"Jane\")\n\n\u00a0\u00a0\u00a0staff2.start()\n\n\u00a0\u00a0\u00a0staff1.join()\n\n\u00a0\u00a0\u00a0staff2.join()\n\nif __name__ == \"__main__\":\n\n\u00a0s = time.perf_counter()\n\n\u00a0main()\n\n\u00a0elapsed = time.perf_counter() - s\n\n\u00a0print(f\"Orders completed in {elapsed:0.2f} seconds.\")<\/pre>\n
Lorsque vous ex\u00e9cutez le code ci-dessus, une erreur peut se produire dans l’un des threads, indiquant qu’il essaie d’obtenir une t\u00e2che \u00e0 partir d’une liste vide. Vous vous demandez peut-\u00eatre pourquoi c’est le cas, puisque nous avons une condition dans la boucle while<\/code> qui fait qu’elle continue uniquement si la file d’attente task_queue<\/code> n’est pas vide. Mais nous obtenons quand m\u00eame une erreur, car nous avons rencontr\u00e9 des conditions de concurrence.<\/p>\n
Conditions de concurrence<\/h3>\n
Des conditions de concurrence (race conditions) peuvent se produire lorsque plusieurs threads tentent d’acc\u00e9der \u00e0 la m\u00eame ressource ou aux m\u00eames donn\u00e9es en m\u00eame temps et causent des probl\u00e8mes dans le syst\u00e8me. Le moment et l’ordre d’acc\u00e8s \u00e0 la ressource sont importants pour la logique du programme, et une chronologie impr\u00e9visible ou l’entrelacement de plusieurs threads acc\u00e9dant \u00e0 des donn\u00e9es partag\u00e9es pour les modifier peuvent provoquer des erreurs.<\/p>\n
Pour r\u00e9soudre la condition de concurrence dans notre programme, nous allons d\u00e9ployer un verrou sur la file d’attente task_queue<\/code>\u00a0:<\/p>\n
queue_lock = threading.Lock()<\/pre>\n
Pour que cela fonctionne, nous devons nous assurer de disposer des autorisations d’acc\u00e8s n\u00e9cessaires pour v\u00e9rifier la longueur de la file d’attente et r\u00e9cup\u00e9rer les t\u00e2ches qui en sont extraites. Tant que nous avons les droits, les autres threads ne peuvent pas acc\u00e9der \u00e0 la file d’attente\u00a0:<\/p>\n
def working():\n\n\u00a0\u00a0\u00a0while True:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0with queue_lock:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if len(order_queue) == 0:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0else:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task = order_queue.pop(0)\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"{threading.current_thread().name} is working...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task()\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"{threading.current_thread().name} finish task...\")\n\n```\n\nBased on what we have learned so far, we can complete our final code with threading like this:\n\n```\n\nimport logging\n\nimport threading\n\nimport time\n\nlogger = logging.getLogger(__name__)\n\nlogging.basicConfig(filename=\"pyburger_threads.log\", level=logging.INFO)\n\nqueue_lock = threading.Lock()\n\ntask_queue = []\n\norder_num = 0\n\nclosing = False\n\ndef take_order():\n\n\u00a0\u00a0\u00a0global order_num, closing\n\n\u00a0\u00a0\u00a0try:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0order_num += 1\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(f\"Taking Order #{order_num:04d}...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"Order burger and fries for order #{order_num:04d}:\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0burger_num = input(\"Number of burgers:\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0for i in range(int(burger_num)):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0with queue_lock:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task_queue.append(make_burger(f\"{order_num:04d}-burger{i:02d}\"))\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0fries_num = input(\"Number of fries:\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0for i in range(int(fries_num)):\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0with queue_lock:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task_queue.append(make_fries(f\"{order_num:04d}-fries{i:02d}\"))\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(f\"Order #{order_num:04d} queued.\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(f\"Order #{order_num:04d} queued, please wait.\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0with queue_lock:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task_queue.append(take_order)\n\n\u00a0\u00a0\u00a0except ValueError:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0print(\"Goodbye!\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(\"Closing down... stop taking orders and finish all tasks.\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0closing = True\n\ndef make_burger(order_num):\n\n\u00a0\u00a0\u00a0def making_burger():\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(f\"Preparing burger #{order_num}...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0time.sleep(5)\u00a0 # time for making the burger\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(f\"Burger made #{order_num}\")\n\n\u00a0\u00a0\u00a0return making_burger\n\ndef make_fries(order_num):\n\n\u00a0\u00a0\u00a0def making_fries():\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(f\"Preparing fried #{order_num}...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0time.sleep(2)\u00a0 # time for making fries\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(f\"Fries made #{order_num}\")\n\n\u00a0\u00a0\u00a0return making_fries\n\ndef working():\n\n\u00a0\u00a0\u00a0while True:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0with queue_lock:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if len(task_queue) == 0:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if closing:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0else:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task = None\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0else:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task = task_queue.pop(0)\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if task:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(f\"{threading.current_thread().name} is working...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0task()\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0logger.info(f\"{threading.current_thread().name} finish task...\")\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0else:\n\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0time.sleep(1)\u00a0 # rest\n\ndef main():\n\n\u00a0\u00a0\u00a0print(\"Welcome to Pyburger!\")\n\n\u00a0\u00a0\u00a0logger.info(\"Ready for business!\")\n\n\u00a0\u00a0\u00a0task_queue.append(take_order)\n\n\u00a0\u00a0\u00a0staff1 = threading.Thread(target=working, name=\"John\")\n\n\u00a0\u00a0\u00a0staff1.start()\n\n\u00a0\u00a0\u00a0staff2 = threading.Thread(target=working, name=\"Jane\")\n\n\u00a0\u00a0\u00a0staff2.start()\n\n\u00a0\u00a0\u00a0staff1.join()\n\n\u00a0\u00a0\u00a0staff2.join()\n\n\u00a0\u00a0\u00a0logger.info(\"All tasks finished. Closing now.\")\n\nif __name__ == \"__main__\":\n\n\u00a0\u00a0\u00a0s = time.perf_counter()\n\n\u00a0\u00a0\u00a0main()\n\n\u00a0\u00a0\u00a0elapsed = time.perf_counter() - s\n\n\u00a0\u00a0\u00a0logger.info(f\"Orders completed in {elapsed:0.2f} seconds.\")<\/pre>\n
Si vous comparez les deux extraits de code utilisant asyncio<\/code> et threading<\/code>, leurs r\u00e9sultats devraient \u00eatre similaires. Vous vous demandez peut-\u00eatre lequel est le meilleur et pourquoi choisir l’un plut\u00f4t que l’autre.<\/p>\n
En pratique, l’\u00e9criture de code asyncio<\/code> est plus facile que le multithreading, car nous n’avons pas \u00e0 nous occuper nous-m\u00eames des conditions de concurrence potentielles et des blocages. Par d\u00e9faut, les contr\u00f4les sont transmis entre les coroutines, donc aucun verrou n’est n\u00e9cessaire. Les threads Python ont toutefois la possibilit\u00e9 de fonctionner en parall\u00e8le, mais pas la plupart du temps si le GIL est en place. Nous pourrons revenir sur ce point lorsque nous parlerons de nogil (sans thread) Python dans le prochain article.<\/p>\n
B\u00e9n\u00e9ficier de la concurrence<\/h2>\n
Pourquoi utiliser la concurrence en programmation\u00a0? Principalement pour une raison\u00a0: la vitesse. Comme nous l’avons illustr\u00e9 ci-dessus, les t\u00e2ches s’accomplissent plus rapidement si nous pouvons r\u00e9duire le temps d’attente. Plusieurs types d’attente existent en informatique, et pour chacun d’entre eux, nous avons tendance \u00e0 utiliser des m\u00e9thodes diff\u00e9rentes pour gagner du temps.<\/p>\n
T\u00e2ches associ\u00e9es aux I\/O<\/h3>\n
Une t\u00e2che ou un programme est consid\u00e9r\u00e9 comme associ\u00e9 aux entr\u00e9es\/sorties (I\/O) lorsque sa vitesse d’ex\u00e9cution est principalement limit\u00e9e par la vitesse des op\u00e9rations d’I\/O (par exemple la lecture \u00e0 partir d’un fichier ou d’un r\u00e9seau, ou l’attente d’une entr\u00e9e utilisateur). Les op\u00e9rations d’I\/O sont g\u00e9n\u00e9ralement plus lentes que les autres op\u00e9rations du processeur et, par cons\u00e9quent, les t\u00e2ches qui en impliquent un grand nombre peuvent prendre beaucoup plus de temps. Parmi ces t\u00e2ches, on peut citer la lecture de donn\u00e9es \u00e0 partir d’une base de donn\u00e9es, la gestion de requ\u00eates web ou le recours \u00e0 des fichiers volumineux.<\/p>\n
L’utilisation de la concurrence async\/await<\/code> peut aider \u00e0 optimiser le temps d’attente pendant les t\u00e2ches li\u00e9es aux I\/O en d\u00e9bloquant la s\u00e9quence de traitement pour que d’autres t\u00e2ches soient prises en charge pendant l’attente.<\/p>\n
La concurrence async\/await<\/code> est b\u00e9n\u00e9fique dans de nombreuses applications Python, telles que les applications web qui impliquent beaucoup de communication avec des bases de donn\u00e9es et la gestion de requ\u00eates web. Les interfaces utilisateur graphiques (GUI) peuvent \u00e9galement b\u00e9n\u00e9ficier de la simultan\u00e9it\u00e9 async\/await<\/code> en permettant d’effectuer des t\u00e2ches en arri\u00e8re-plan pendant que l’utilisateur interagit avec l’application.<\/p>\n
T\u00e2ches associ\u00e9es au processeur<\/h3>\n
Une t\u00e2che ou un programme est consid\u00e9r\u00e9 comme li\u00e9 au processeur lorsque sa vitesse d’ex\u00e9cution est principalement limit\u00e9e par la vitesse du CPU. Parmi les exemples typiques, on trouve le traitement d’images ou de vid\u00e9os, comme le redimensionnement ou l’\u00e9dition, et les calculs math\u00e9matiques complexes, tels que la multiplication matricielle ou l’entra\u00eenement de mod\u00e8les de machine learning.<\/p>\n
Contrairement aux t\u00e2ches associ\u00e9es aux I\/O, les t\u00e2ches li\u00e9es au processeur peuvent rarement \u00eatre optimis\u00e9es \u00e0 l’aide de la concurrence async\/await<\/code>, car le processeur est d\u00e9j\u00e0 occup\u00e9 \u00e0 travailler sur les t\u00e2ches. Si vous avez plusieurs processeurs dans votre machine, ou si vous pouvez d\u00e9charger certaines de ces t\u00e2ches sur un ou plusieurs GPU, les t\u00e2ches li\u00e9es au processeur peuvent \u00eatre termin\u00e9es plus rapidement gr\u00e2ce \u00e0 la cr\u00e9ation de threads suppl\u00e9mentaires pour effectuer un multitraitement. Le multitraitement peut optimiser l’utilisation de ces CPU et GPU, ce qui explique \u00e9galement pourquoi de nombreux mod\u00e8les de machine learning et d’IA sont aujourd’hui entra\u00een\u00e9s sur plusieurs GPU.<\/p>\n
Cela reste toutefois difficile \u00e0 r\u00e9aliser avec du code Python pur, car Python lui-m\u00eame est con\u00e7u pour fournir des couches abstraites afin que les utilisateurs n’aient pas \u00e0 contr\u00f4ler les processus de calcul de niveau inf\u00e9rieur. De plus, le GIL de Python limite le partage des ressources Python entre plusieurs threads sur votre ordinateur. R\u00e9cemment, Python\u00a03.13 a permis de supprimer le GIL, pour permettre un v\u00e9ritable multithreading. Nous parlerons du GIL et de la possibilit\u00e9 de s’en passer dans un prochain article de blog.<\/p>\n
Parfois, aucune des m\u00e9thodes que nous avons mentionn\u00e9es ci-dessus n’est capable d’acc\u00e9l\u00e9rer suffisamment les t\u00e2ches li\u00e9es au CPU. Dans ces cas, il peut \u00eatre n\u00e9cessaire de diviser les t\u00e2ches li\u00e9es au processeur en plus petites t\u00e2ches afin de pouvoir les ex\u00e9cuter simultan\u00e9ment sur plusieurs threads, plusieurs processeurs ou m\u00eame plusieurs machines. Il s’agit du traitement parall\u00e8le, et il peut \u00eatre n\u00e9cessaire de r\u00e9\u00e9crire compl\u00e8tement votre code pour l’impl\u00e9menter. En Python, le paquet multiprocessing<\/code> offre une concurrence locale et distante, qui peut \u00eatre utilis\u00e9e pour contourner la limitation du GIL. Nous en examinerons \u00e9galement quelques exemples dans un prochain article de blog.<\/p>\n
D\u00e9bogage du code concurrent dans PyCharm<\/h2>\n
Le d\u00e9bogage de code asynchrone ou concurrent peut s’av\u00e9rer compliqu\u00e9, car le programme n’est ps ex\u00e9cut\u00e9 de mani\u00e8re s\u00e9quentielle, ce qui rend difficile de voir o\u00f9 et quand le code est ex\u00e9cut\u00e9. De nombreux d\u00e9veloppeurs utilisent print<\/code> pour aider \u00e0 tracer le flux du code, mais cette approche n’est pas recommand\u00e9e, car elle est tr\u00e8s maladroite, et l’utiliser pour \u00e9tudier un programme complexe, comme un programme concurrent, n’est pas facile. De plus, remettre le code en ordre apr\u00e8s cela est fastidieux.<\/p>\n
De nombreux IDE fournissent des d\u00e9bogueurs, qui sont parfaits pour inspecter les variables et le flux du programme. Les d\u00e9bogueurs fournissent \u00e9galement une trace de pile claire sur plusieurs threads. Voyons comment suivre les files d’attente task_queue<\/code> de notre exemple de simulation de restaurant dans PyCharm<\/a>.<\/p>\n
Tout d’abord, nous allons placer quelques points d’arr\u00eat dans notre code. Pour ce faire, cliquez sur le num\u00e9ro de la ligne sur laquelle vous souhaitez que le d\u00e9bogueur s’arr\u00eate. Le num\u00e9ro de la ligne se transforme en point rouge, indiquant qu’un point d’arr\u00eat y est d\u00e9fini. Nous allons placer des points d’arr\u00eat aux lignes\u00a023, 27 et 65, o\u00f9 la file d’attente des t\u00e2ches task_queue<\/code> est modifi\u00e9e dans plusieurs threads.<\/p>\n
\"\"<\/figure>\n
\"\"<\/figure>\n
Nous pouvons ensuite ex\u00e9cuter le programme en mode d\u00e9bogage en cliquant sur la petite ic\u00f4ne d’insecte en haut \u00e0 droite.<\/p>\n
\"\"<\/figure>\n
Un clic sur l’ic\u00f4ne ouvre la fen\u00eatre Debug<\/em>. Le programme s’ex\u00e9cute alors jusqu’\u00e0 atteindre le premier point d’arr\u00eat mis en \u00e9vidence dans le code.<\/p>\n
\"\"<\/figure>\n
Ici, nous voyons que le thread John<\/code> essaie de reprendre la t\u00e2che, et la ligne\u00a065 est mise en \u00e9vidence. \u00c0 ce stade, la ligne en surbrillance n’a pas encore \u00e9t\u00e9 ex\u00e9cut\u00e9e. Cela nous permet d’inspecter les variables avant d’entrer dans le point d’arr\u00eat.<\/p>\n
Voyons ce que contient la file d’attente task_queue<\/code>. Pour cela, vous pouvez simplement commencer \u00e0 taper dans la fen\u00eatre Debug<\/em>, comme indiqu\u00e9 ci-dessous.<\/p>\n
\"\"<\/figure>\n
S\u00e9lectionnez ou tapez \u00ab\u00a0task_queue\u00a0\u00bb, puis appuyez sur Entr\u00e9e<\/em>. Vous verrez que la t\u00e2che take_order<\/code> se trouve dans la file d’attente.<\/p>\n
\"\"<\/figure>\n
Maintenant, ex\u00e9cutons le point d’arr\u00eat en cliquant sur le bouton Step in<\/em>, comme indiqu\u00e9 ci-dessous.<\/p>\n
\"\"<\/figure>\n
Apr\u00e8s avoir cliqu\u00e9 dessus et inspect\u00e9 la fen\u00eatre Special Variables<\/em> qui s’affiche alors, nous voyons que la variable task est maintenant take_order<\/code> dans le thread John<\/code>.<\/p>\n
\"\"<\/figure>\n
Lorsque nous interrogeons \u00e0 nouveau la task_queue<\/code>, nous constatons que la liste est vide.<\/p>\n
\"\"<\/figure>\n
Cliquons maintenant sur le bouton Resume Program<\/em> et laissons le programme s’ex\u00e9cuter.<\/p>\n
\"\"<\/figure>\n
Lorsque le programme atteint la partie d’entr\u00e9e par l’utilisateur, PyCharm nous am\u00e8ne \u00e0 la fen\u00eatre Console<\/em> afin que nous puissions fournir l’entr\u00e9e. Supposons que nous voulons deux burgers. Tapez \u00ab\u00a02\u00a0\u00bb et appuyez sur Entr\u00e9e<\/em>.<\/p>\n
\"\"<\/figure>\n
Nous atteignons maintenant le deuxi\u00e8me point d’arr\u00eat. Si nous cliquons sur Threads & Variables<\/em> pour revenir \u00e0 cette fen\u00eatre, nous verrons que burger_num<\/code> est \u00e9gal \u00e0 deux, comme nous l’avons demand\u00e9.<\/p>\n
\"\"<\/figure>\n
Entrons maintenant dans le point d’arr\u00eat et inspectons la task_queue<\/code>, comme pr\u00e9c\u00e9demment. Nous voyons qu’une t\u00e2che make_burger<\/code> a \u00e9t\u00e9 ajout\u00e9e.<\/p>\n
\"\"<\/figure>\n
Nous laissons le programme s’ex\u00e9cuter \u00e0 nouveau, et si nous avan\u00e7ons pas \u00e0 pas dans le point d’arr\u00eat lorsqu’il s’arr\u00eate, nous voyons que Jane<\/code> reprend la t\u00e2che.<\/p>\n
\"\"<\/figure>\n
Vous pouvez inspecter le reste du code vous-m\u00eame. Lorsque vous avez termin\u00e9, appuyez simplement sur le bouton rouge Stop<\/em> en haut de la fen\u00eatre.<\/p>\n
\"\"<\/figure>\n
Avec le d\u00e9bogueur de PyCharm, vous pouvez tr\u00e8s facilement suivre l’ex\u00e9cution de votre programme sur diff\u00e9rents threads et inspecter les diff\u00e9rentes variables.<\/p>\n
\n
Conclusion<\/h2>\n
Nous avons vu dans cet article les bases de la concurrence en Python, et j’esp\u00e8re que vous serez en mesure de les ma\u00eetriser avec de la pratique. Dans le prochain article, nous examinerons le GIL Python, son r\u00f4le et ce qui change en son absence.<\/p>\n
PyCharm fournit des outils puissants pour travailler avec du code Python concurrent. Comme nous l’avons vu, le d\u00e9bogueur permet inspection \u00e9tape par \u00e9tape du code asynchrone et multithread, ce qui vous aide \u00e0 suivre le flux d’ex\u00e9cution, \u00e0 surveiller les ressources partag\u00e9es et \u00e0 d\u00e9tecter les probl\u00e8mes. Avec des points d’arr\u00eat intuitifs, des vues de variables en temps r\u00e9el, une int\u00e9gration transparente de la console pour la saisie utilisateur et une prise en charge robuste de la journalisation, PyCharm facilite l’\u00e9criture, le test et le d\u00e9bogage des applications de fa\u00e7on claire et assur\u00e9e.<\/p>\n
\n
T\u00e9l\u00e9chargez PyCharm d\u00e8s maintenant<\/a><\/div>\n<\/div>\n\n\n
Auteur de l’article original en anglais<\/em> :<\/p>\n\n\n    
\n        
\n            
\n                
\n                    \"Cheuk\n                <\/div>\n                
\n                                            
Cheuk Ting Ho<\/h4>\n                                                        <\/div>\n            <\/div>\n        <\/div>\n    <\/div>\n","protected":false},"author":813,"featured_media":573955,"comment_status":"closed","ping_status":"closed","template":"","categories":[1401,2347,8377],"tags":[6939,5377],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/pycharm\/671429"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/pycharm"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/types\/pycharm"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/users\/813"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/comments?post=671429"}],"version-history":[{"count":5,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/pycharm\/671429\/revisions"}],"predecessor-version":[{"id":671435,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/pycharm\/671429\/revisions\/671435"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media\/573955"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media?parent=671429"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/categories?post=671429"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/tags?post=671429"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/cross-post-tag?post=671429"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}