{"id":591090,"date":"2025-06-30T01:09:00","date_gmt":"2025-06-30T00:09:00","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=pycharm&p=591090"},"modified":"2025-08-12T01:36:06","modified_gmt":"2025-08-12T00:36:06","slug":"python-mas-rapido-simultaneidad-con-async-await-y-threading","status":"publish","type":"pycharm","link":"https:\/\/blog.jetbrains.com\/es\/pycharm\/2025\/06\/python-mas-rapido-simultaneidad-con-async-await-y-threading\/","title":{"rendered":"Python m\u00e1s r\u00e1pido: simultaneidad con async\/await y threading"},"content":{"rendered":"
\"\"<\/figure>\n

Si lleva tiempo codificando con Python, y en especial si ha usado marcos de trabajo y bibliotecas como FastAPI y discord.py, probablemente haya usado async\/await<\/code> o asyncio<\/code>. Quiz\u00e1s haya o\u00eddo afirmaciones del tipo \u00abel multihilo en Python no existe\u00bb y quiz\u00e1s tambi\u00e9n conozca el (tristemente) famoso GIL de Python. Vista la negaci\u00f3n acerca del multihilo de Python, quiz\u00e1s se est\u00e9 preguntando cu\u00e1l es realmente la diferencia entre async\/await<\/code> y el multihilo, especialmente al programar con Python. Si es as\u00ed, \u00a1este art\u00edculo es para usted!<\/p>\n

\u00bfQu\u00e9 es el multihilo?<\/h2>\n

En programaci\u00f3n, el multihilo se refiere a la capacidad de un programa para ejecutar varias tareas secuenciales (llamadas hilos o subprocesos) de forma simult\u00e1nea. Estos subprocesos pueden ejecutarse en uno o en varios n\u00facleos del procesador. Sin embargo, debido a la limitaci\u00f3n del Global Interpreter Lock (GIL), en Python el multihilo solo se procesa en un n\u00facleo. La excepci\u00f3n es nogil (tambi\u00e9n llamada thread-free) en Python, que elimina el GIL y de la cual hablaremos en la segunda parte de esta serie. En este art\u00edculo del blog, asumiremos que el GIL siempre est\u00e1 presente.<\/p>\n

\u00bfQu\u00e9 es la simultaneidad?<\/h2>\n

La simultaneidad en programaci\u00f3n implica que el ordenador est\u00e1 haciendo m\u00e1s de una cosa a la vez, o parece estar haci\u00e9ndolo, aunque todas las tareas se ejecuten en un \u00fanico procesador. Al gestionar los recursos y las interacciones entre las distintas partes de un programa, es posible que todas las tareas avancen de forma independiente y en intervalos de tiempo solapados.<\/p>\n

Tanto asyncio<\/code> como threading<\/code> se comportan de forma simult\u00e1nea en Python<\/h3>\n

En t\u00e9rminos generales, las bibliotecas de Python asyncio<\/code> y threading<\/code> permiten la apariencia de simultaneidad. Sin embargo, sus CPU no est\u00e1n haciendo varias cosas a la vez exactamente, sino que solo lo parece.<\/p>\n

Imagine que est\u00e1 organizando una cena de varios platos para sus invitados y algunos de los platos tardan en cocinarse, como la tarta que hay que meter en el horno o la sopa que se est\u00e1 cociendo a fuego lento. Mientras esperamos a que se terminen de cocinar, no nos quedamos de brazos cruzados, sino que hacemos otra cosa. Esto es parecido a la simultaneidad en Python. A veces, el proceso de Python est\u00e1 esperando a que algo termine. Por ejemplo, el sistema operativo gestiona algunos procesos de entrada\/salida (E\/S) y, en este lapso, el proceso de Python est\u00e1 en pausa. Entonces, podemos usar async para permitir que otro proceso de Python se ejecute mientras tanto.<\/p>\n

\"Multihilo<\/figure>\n

La diferencia es qui\u00e9n se encarga<\/h3>\n

Si tanto asyncio<\/code> como threading<\/code> se comportan de forma simult\u00e1nea, \u00bfen qu\u00e9 se diferencian? La principal diferencia es una cuesti\u00f3n de qui\u00e9n y cu\u00e1ndo se encarga del proceso que se est\u00e1 ejecutando. En el caso de async\/await<\/code>, el enfoque a veces se conoce como \u00absimultaneidad cooperativa\u00bb. Una corrutina o un futuro cede su control a otra corrutina o futuro para darles una oportunidad. Por otro lado, en threading<\/code>, el gestor del sistema operativo controlar\u00e1 qu\u00e9 proceso se est\u00e1 ejecutando.<\/p>\n

La simultaneidad cooperativa es como una reuni\u00f3n en la que se va pasando un micr\u00f3fono para que la gente tome la palabra. Quien tenga el micr\u00f3fono puede hablar y, cuando haya terminado o no tenga nada m\u00e1s que a\u00f1adir, pasar\u00e1 el micr\u00f3fono a la siguiente persona. Por el contrario, el multihilo es una reuni\u00f3n en la que hay un moderador que decide qui\u00e9n tiene la palabra en cada momento.\u00a0<\/p>\n

Escribir c\u00f3digo simult\u00e1neo en Python<\/h2>\n

Veamos c\u00f3mo funciona la simultaneidad en Python escribiendo algunos ejemplos de c\u00f3digo. Crearemos una simulaci\u00f3n de un restaurante de comida r\u00e1pida usando tanto asyncio<\/code> como threading<\/code>.<\/p>\n

C\u00f3mo funciona async\/await<\/code> en Python<\/h3>\n

El paquete de asyncio<\/code> se introdujo en Python 3.4, mientras que las palabras clave async<\/code> y await<\/code> se introdujeron en Python 3.5. Una de las principales cosas que hacen posible async\/await<\/code> es el uso de corrutinas. Las corrutinas en Python son, en realidad, generadores reutilizados que poder poner en pausa y pasar de nuevo a la funci\u00f3n principal.<\/p>\n

Ahora, imagine un restaurante de hamburguesas donde solo haya una persona trabajando. Los pedidos se preparan seg\u00fan el orden en que van entrando y no se pueden realizar acciones as\u00edncronas:<\/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
Esto tardar\u00e1 un rato en estar listo:<\/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
Ahora, imaginemos que el restaurante contrata a m\u00e1s personal para que sea posible realizar el trabajo de forma simult\u00e1nea:<\/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
Veamos en qu\u00e9 se diferencian:<\/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
Con las funciones proporcionadas por asyncio<\/code>, como run<\/code> y gather<\/code>, y las palabras clave async<\/code> y await<\/code>, hemos creado corrutinas que pueden preparar hamburguesas de forma simult\u00e1nea.<\/p>\n
Ahora, vayamos un poco m\u00e1s all\u00e1 y creemos una simulaci\u00f3n m\u00e1s complicada. Vamos a imaginar que solo tenemos dos trabajadores y solo podemos hacer dos hamburguesas a la vez.<\/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
Aqu\u00ed utilizaremos una cola para retener las tareas y el personal las ir\u00e1 recogiendo.<\/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
En este ejemplo, utilizamos asyncio.Queue<\/code> para almacenar las tareas, pero ser\u00e1 m\u00e1s \u00fatil si tenemos varios tipos de tareas, como se muestra en el siguiente ejemplo.<\/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
En este ejemplo, hay varias tareas, como hacer patatas fritas, que lleva menos tiempo, o tomar nota de los pedidos, que implica recibir informaci\u00f3n del usuario.\u00a0<\/p>\n
Tenga en cuenta que el programa deja de esperar la informaci\u00f3n del usuario e incluso el personal que no est\u00e1 tomando nota del pedido deja de trabajar en segundo plano. Esto ocurre porque la funci\u00f3n input<\/code> no es async y, por lo tanto, no se la espera. Recuerde que el control en c\u00f3digo async solo se libera cuando se le espera. Para solucionarlo, podemos sustituir<\/p>\n
input(\"Number of burgers:\")<\/pre>\n
Por\u00a0<\/p>\n
await asyncio.to_thread(input, \"Number of burgers:\")<\/pre>\n
Y haremos lo mismo en el caso de las patatas fritas (f\u00edjese en el siguiente c\u00f3digo). Observe que ahora el programa se ejecuta en un bucle infinito. Si queremos detenerlo, podemos bloquear de forma deliberada el programa con una entrada no v\u00e1lida.<\/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
Con asyncio.to_thread<\/code>, hemos puesto la funci\u00f3n input<\/code> en un subproceso independiente (vea esta referencia<\/a>). Sin embargo, debe tener en cuenta que este truco solo desbloquea tareas limitadas por E\/S si el GIL de Python est\u00e1 presente.<\/p>\n
Si ejecuta el c\u00f3digo anterior, tambi\u00e9n ver\u00e1 que la E\/S est\u00e1ndar en el terminal aparece desordenada. La E\/S del usuario y el registro de lo que est\u00e1 sucediendo deben estar separados. Podemos poner el registro en un log para inspeccionarlo m\u00e1s tarde.\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
En este bloque de c\u00f3digo final, hemos registrado la informaci\u00f3n de la simulaci\u00f3n en pyburger.log<\/code> y reservado el terminal para mensajes dirigidos a los clientes. Tambi\u00e9n detectamos entradas no v\u00e1lidas durante el proceso de tomar nota del pedido y cambiamos el indicador closing<\/code> a True<\/code> si la entrada no era v\u00e1lida, asumiendo que el usuario quer\u00eda salir. Cuando el indicador closing<\/code> se establece en True<\/code>, el trabajador har\u00e1 return<\/code> (regresar\u00e1), lo que pondr\u00e1 fin al bucle while<\/code> infinito de la corrutina.<\/p>\n
\u00bfC\u00f3mo funcionan los threading<\/code> en Python?<\/h3>\n
En el ejemplo anterior, pusimos una tarea de E\/S en otro subproceso. Se estar\u00e1 preguntando si podemos poner todas las tareas en subprocesos separados y dejar que se ejecuten de forma simult\u00e1nea. Vamos a probar usando threading<\/code> en lugar de asyncio<\/code>.<\/p>\n
F\u00edjese en el siguiente c\u00f3digo, donde creamos hamburguesas de forma simult\u00e1nea sin ninguna limitaci\u00f3n:<\/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
En el primer bucle for<\/code> de main<\/code>, las tareas se crean en diferentes subprocesos y se ponen en marcha r\u00e1pidamente. El segundo bucle for<\/code> se asegura de que todas las hamburguesas est\u00e9n hechas antes de que el programa siga adelante (es decir, antes de que vuelva a main<\/code>).<\/p>\n
Se complica cuando solo hay dos personas trabajando. Los trabajadores est\u00e1n representados con un subproceso y seleccionar\u00e1n tareas de una lista normal donde se almacenan todas.<\/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
Al ejecutar el c\u00f3digo anterior, puede producirse un error en uno de los subprocesos que indique que est\u00e1 intentando seleccionar una tarea de una lista vac\u00eda. Quiz\u00e1s se pregunte por qu\u00e9 ocurre esto, ya que tenemos una condici\u00f3n en el bucle while<\/code> que hace que contin\u00fae solo si la tarea task_queue<\/code> no est\u00e1 vac\u00eda. Sin embargo, sigue apareciendo el error porque hemos encontrado condiciones de carrera.<\/p>\n
Condiciones de carrera<\/h3>\n
Las condiciones de carrera pueden producirse cuando varios subprocesos intentan acceder al mismo recurso o a los mismos datos a la vez y causan problemas en el sistema. El momento y el orden en que se accede al recurso son importantes para la l\u00f3gica del programa, y un momento impredecible o la intercalaci\u00f3n de varios subprocesos accediendo y modificando datos compartidos puede causar errores.<\/p>\n
Para resolver la condici\u00f3n de carrera en nuestro programa, vamos a implementar un bloqueo a la tarea task_queue<\/code>:<\/p>\n
queue_lock = threading.Lock()<\/pre>\n
Para que funcione, necesitamos asegurarnos de que tenemos derechos de acceso a la cola al comprobar su longitud y seleccionar tareas. Mientras tengamos los derechos, no habr\u00e1 otros subprocesos que puedan acceder a la cola:<\/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 compara los dos fragmentos de c\u00f3digo utilizando asyncio<\/code> y threading<\/code>, los resultados deber\u00edan ser similares. Quiz\u00e1s se pregunte cu\u00e1l es mejor y por qu\u00e9 deber\u00eda elegir uno u otro.<\/p>\n
En la pr\u00e1ctica, escribir c\u00f3digo asyncio<\/code> es m\u00e1s f\u00e1cil que el multihilo porque no tenemos que preocuparnos por las posibles condiciones de carrera y los interbloqueos. Las corrutinas pasan controles de forma predeterminada, por lo que no se necesitan bloqueos. Sin embargo, los subprocesos de Python pueden ejecutarse en paralelo, aunque no siempre con el GIL presente. Podemos volver sobre esto cuando hablemos de Python nogil (sin subprocesos) en el pr\u00f3ximo art\u00edculo del blog.<\/p>\n
Ventajas de la simultaneidad<\/h2>\n
\u00bfPor qu\u00e9 utilizar la simultaneidad en programaci\u00f3n? Por una sencilla raz\u00f3n: la velocidad. Como hemos visto anteriormente, las tareas pueden completarse m\u00e1s r\u00e1pidamente si podemos reducir el tiempo de espera. Hay varios tipos de espera en computaci\u00f3n y, en cada caso, tendemos a usar diferentes m\u00e9todos para ahorrar tiempo.<\/p>\n
Tareas ligadas a la E\/S<\/h3>\n
Se considera que una tarea o programa est\u00e1 ligado a la entrada\/salida (E\/S) cuando su velocidad de ejecuci\u00f3n est\u00e1 limitada principalmente por la velocidad de las operaciones de E\/S, como la lectura de un archivo o de la red, o la espera de la informaci\u00f3n que introduzca del usuario. Las operaciones de E\/S suelen ser m\u00e1s lentas que otras operaciones de la CPU y, por tanto, las tareas que implican muchas de ellas pueden ser bastante m\u00e1s lentas. Algunos ejemplos de ello son la lectura de datos de una base de datos, la gesti\u00f3n de peticiones web o el trabajo con archivos de gran tama\u00f1o.<\/p>\n
El uso de la simultaneidad async\/await<\/code> puede ayudar a optimizar el tiempo de espera durante las tareas vinculadas a E\/S desbloqueando la secuencia de procesamiento y permitiendo que se lleven a cabo otras tareas mientras se espera.<\/p>\n
La simultaneidad async\/await<\/code> tiene ventajas en muchas aplicaciones de Python, como las aplicaciones web que necesitan mucha comunicaci\u00f3n con bases de datos y el manejo de peticiones web. Las interfaces gr\u00e1ficas de usuario tambi\u00e9n pueden beneficiarse de la simultaneidad async\/await<\/code> al permitir que se lleven a cabo tareas en segundo plano mientras el usuario interact\u00faa con la aplicaci\u00f3n.<\/p>\n
Tareas ligadas a la CPU<\/h3>\n
Una tarea o programa se considera ligado a la CPU cuando su velocidad de ejecuci\u00f3n est\u00e1 limitada principalmente por la velocidad de la CPU. Algunos ejemplos t\u00edpicos son el procesamiento de im\u00e1genes o v\u00eddeo, como el cambio de tama\u00f1o o la edici\u00f3n, y los c\u00e1lculos matem\u00e1ticos complejos, como la multiplicaci\u00f3n de matrices o el entrenamiento de modelos de aprendizaje autom\u00e1tico.<\/p>\n
A diferencia de las tareas de E\/S, las tareas de CPU no suelen poder optimizarse con simultaneidad async\/await<\/code>, ya que la CPU ya est\u00e1 ocupada trabajando en las tareas. Si tiene m\u00e1s de una CPU en la m\u00e1quina, o si puede descargar algunas de estas tareas a una o m\u00e1s GPU, las tareas ligadas a la CPU pueden terminarse m\u00e1s r\u00e1pidamente creando m\u00e1s subprocesos y con multiprocesamiento. El multiprocesamiento puede optimizar el uso de las CPU y las GPU, por lo que muchos modelos de aprendizaje autom\u00e1tico e inteligencia artificial se entrenan actualmente en varias GPU.<\/p>\n
Sin embargo, esto es dif\u00edcil de llevar a cabo con c\u00f3digo Python puro, ya que Python est\u00e1 dise\u00f1ado para proporcionar capas abstractas de forma que los usuarios no tengan que controlar los procesos de computaci\u00f3n de nivel inferior. Adem\u00e1s, el GIL de Python limita el uso compartido de los recursos de Python entre varios subprocesos del ordenador. Recientemente, Python 3.13 incorpor\u00f3 la posibilidad de eliminar el GIL, lo que permite lograr un multihilo real. En el pr\u00f3ximo art\u00edculo del blog, hablaremos del GIL y de la posibilidad de prescindir de \u00e9l.<\/p>\n
A veces, ninguno de los m\u00e9todos mencionados anteriormente es capaz de acelerar suficientemente las tareas ligadas a la CPU. En ese caso, puede que sea necesario dividir las tareas ligadas a la CPU en otras m\u00e1s peque\u00f1as para que puedan ejecutarse de forma simult\u00e1nea en varios subprocesos, varios procesadores o incluso varias m\u00e1quinas. Esto es el procesamiento paralelo y puede que tenga que reescribir el c\u00f3digo por completo para implementarlo. En Python, el paquete multiprocessing<\/code> ofrece simultaneidad local y remota, que puede utilizarse para evitar la limitaci\u00f3n del GIL. Tambi\u00e9n veremos algunos ejemplos de ello en el pr\u00f3ximo art\u00edculo del blog.<\/p>\n
Depuraci\u00f3n de c\u00f3digo simult\u00e1neo en PyCharm<\/h2>\n
Depurar c\u00f3digo async o simult\u00e1neo puede ser dif\u00edcil, ya que el programa no se ejecuta en secuencia, lo que significa que es dif\u00edcil ver d\u00f3nde y cu\u00e1ndo se est\u00e1 ejecutando el c\u00f3digo. Muchos desarrolladores utilizan print<\/code> para ayudar a trazar el flujo del c\u00f3digo, pero no recomendamos este enfoque, ya que es poco preciso y utilizarlo para investigar un programa complejo, como uno simult\u00e1neo, no es nada f\u00e1cil. Adem\u00e1s, despu\u00e9s no siempre es f\u00e1cil poner orden.<\/p>\n
Muchos IDE tienen depuradores, que son geniales para inspeccionar variables y el flujo del programa. Los depuradores tambi\u00e9n proporcionan un seguimiento claro de la pila a trav\u00e9s de varios subprocesos. Veamos c\u00f3mo podemos rastrear la tarea task_queue<\/code> de nuestro ejemplo de simulaci\u00f3n de restaurante en PyCharm<\/a>.<\/p>\n
Primero, pondremos algunos puntos de interrupci\u00f3n en el c\u00f3digo. Puede hacerlo haciendo clic en el n\u00famero de la l\u00ednea donde quiere que el depurador haga una pausa. El n\u00famero de l\u00ednea se convertir\u00e1 en un punto rojo, indicando que all\u00ed se establece un punto de interrupci\u00f3n. Pondremos puntos de interrupci\u00f3n en las l\u00edneas 23, 27 y 65, donde se modifica la tarea task_queue<\/code> en varios subprocesos.<\/p>\n
\"\"<\/figure>\n
\"\"<\/figure>\n
A continuaci\u00f3n, podemos ejecutar el programa en modo de depuraci\u00f3n haciendo clic en el peque\u00f1o icono de error de la parte superior derecha.<\/p>\n
\"\"<\/figure>\n
Tras hacer clic en el icono, se abrir\u00e1 la ventana Debug<\/em>. El programa se ejecutar\u00e1 hasta que llegue al primer punto de interrupci\u00f3n resaltado en el c\u00f3digo.<\/p>\n
\"\"<\/figure>\n
Aqu\u00ed vemos que el subproceso John<\/code> est\u00e1 intentando retomar la tarea y la l\u00ednea 65 est\u00e1 resaltada. En este punto, la l\u00ednea resaltada a\u00fan no se ha ejecutado. Esto es \u00fatil cuando queremos inspeccionar las variables antes de entrar en el punto de interrupci\u00f3n.<\/p>\n
Vamos a inspeccionar lo que hay en la tarea task_queue<\/code>. Puede hacerlo simplemente comenzando a escribir en la ventana Debug<\/em>, como se muestra a continuaci\u00f3n.<\/p>\n
\"\"<\/figure>\n
Seleccione o escriba \u00abtask_queue\u00bb y, a continuaci\u00f3n, pulse Intro<\/em>. Ver\u00e1 que la tarea take_order<\/code> est\u00e1 en la cola.<\/p>\n
\"\"<\/figure>\n
Ahora, vamos a ejecutar el punto de interrupci\u00f3n pulsando el bot\u00f3n Step in<\/em>, como se muestra a continuaci\u00f3n.<\/p>\n
\"\"<\/figure>\n
Despu\u00e9s de pulsarlo e inspeccionar la ventana de Special Variables<\/em> que aparece, vemos que ahora la variable de tarea es take_order<\/code> en el subproceso John<\/code>.<\/p>\n
\"\"<\/figure>\n
Al consultar de nuevo la tarea task_queue<\/code>, vemos que ahora la lista est\u00e1 vac\u00eda.<\/p>\n
\"\"<\/figure>\n
Ahora, vamos a pulsar el bot\u00f3n Resume Program<\/em> y a dejar que el programa se ejecute.<\/p>\n
\"\"<\/figure>\n
Cuando el programa llegue a la parte de entrada del usuario, PyCharm nos llevar\u00e1 a la ventana Console<\/em> para que podamos proporcionar la entrada. Pongamos que queremos dos hamburguesas. Escriba \u00ab2\u00bb y pulse Intro<\/em>.<\/p>\n
\"\"<\/figure>\n
Ahora, llegamos al segundo punto de interrupci\u00f3n. Si hacemos clic en Threads & Variables<\/em> para volver a esa ventana, veremos que burger_num<\/code> es dos, tal como lo introdujimos.<\/p>\n
\"\"<\/figure>\n
Ahora, vamos a entrar en el punto de interrupci\u00f3n e inspeccionar la tarea task_queue<\/code>, como hicimos antes. Vemos que se ha a\u00f1adido una tarea make_burger<\/code>.<\/p>\n
\"\"<\/figure>\n
Dejamos que el programa se ejecute de nuevo y, si entramos en el punto de interrupci\u00f3n cuando se detiene, vemos que Jane<\/code> est\u00e1 recogiendo la tarea.<\/p>\n
\"\"<\/figure>\n
Si quiere, puede inspeccionar el resto del c\u00f3digo. Cuando haya terminado, pulse el bot\u00f3n rojo Stop<\/em> en la parte superior de la ventana.<\/p>\n
\"\"<\/figure>\n
Con el depurador en PyCharm, puede seguir la ejecuci\u00f3n del programa a trav\u00e9s de varios subprocesos e inspeccionar diferentes variables muy f\u00e1cilmente.<\/p>\n
\n
Conclusi\u00f3n<\/h2>\n
Ahora, hemos aprendido lo b\u00e1sico de la simultaneidad en Python y esperamos que, con la pr\u00e1ctica, sea capaz de dominarla. En el pr\u00f3ximo art\u00edculo del blog, echaremos un vistazo a la GIL de Python, qu\u00e9 papel desempe\u00f1a y qu\u00e9 cambia cuando est\u00e1 ausente.<\/p>\n
PyCharm cuenta con herramientas potentes para trabajar con c\u00f3digo Python simult\u00e1neo. Como demostramos en este art\u00edculo del blog, el depurador permite inspeccionar paso a paso el c\u00f3digo async y thread, lo que le ayuda rastrear el flujo de ejecuci\u00f3n, supervisar los recursos compartidos y detectar los problemas. Con puntos de interrupci\u00f3n intuitivos, vistas de variables en tiempo real, integraci\u00f3n perfecta de la consola para la entrada del usuario y una s\u00f3lida compatibilidad de registro, PyCharm facilita la escritura, las pruebas y la depuraci\u00f3n de aplicaciones con confianza y claridad.<\/p>\n
\n
Descargue PyCharm ahora<\/a><\/div>\n<\/div>\n\n\n
Art\u00edculo original en ingl\u00e9s de:<\/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":1086,"featured_media":591111,"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\/es\/wp-json\/wp\/v2\/pycharm\/591090"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/pycharm"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/types\/pycharm"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/users\/1086"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/comments?post=591090"}],"version-history":[{"count":4,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/pycharm\/591090\/revisions"}],"predecessor-version":[{"id":591124,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/pycharm\/591090\/revisions\/591124"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/media\/591111"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/media?parent=591090"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/categories?post=591090"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/tags?post=591090"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/es\/wp-json\/wp\/v2\/cross-post-tag?post=591090"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}