Recuerde nuestra hamburgueser\u00eda as\u00edncrona de la primera parte de la serie del blog<\/a>:<\/p>\n
import asyncio\n\nimport time\n\nasync def make_burger(order_num):\n\n print(f\"Preparing burger #{order_num}...\")\n\n await asyncio.sleep(5) # time for making the burger\n\n print(f\"Burger made #{order_num}\")\n\nasync def main():\n\n order_queue = []\n\n for i in range(3):\n\n order_queue.append(make_burger(i))\n\n await asyncio.gather(*(order_queue))\n\nif __name__ == \"__main__\":\n\n s = time.perf_counter()\n\n asyncio.run(main())\n\n elapsed = time.perf_counter() - s\n\n print(f\"Orders completed in {elapsed:0.2f} seconds.\")\n<\/pre>\nPodemos utilizar la biblioteca de multiprocesamiento para hacer lo mismo, por ejemplo:<\/p>\n
import multiprocessing\n\n\nimport time\n\n\ndef make_burger(order_num):\n\n\n print(f\"Preparing burger #{order_num}...\")\n\n\n time.sleep(5) # time for making the burger\n\n\n print(f\"Burger made #{order_num}\")\n\n\n\n\nif __name__ == \"__main__\":\n\n\n print(\"Number of available CPU:\", multiprocessing.cpu_count())\n\n\n\n\n s = time.perf_counter()\n\n\n all_processes = []\n\n\n for i in range(3):\n process = multiprocessing.Process(target=make_burger, args=(i,))\n process.start()\n all_processes.append(process)\n\n\n for process in all_processes:\n process.join()\n\n\n elapsed = time.perf_counter() - s\n\n\n print(f\"Orders completed in {elapsed:0.2f} seconds.\")\n<\/pre>\nComo recordar\u00e1, muchos de los m\u00e9todos del multiprocesamiento son muy similares a los hilos. Para ver la diferencia en el multiprocesamiento,<\/em> exploremos un caso de uso m\u00e1s complejo:<\/p>\nimport multiprocessing\nimport time\nimport queue\n\n\n\n\ndef make_burger(order_num, item_made):\n name = multiprocessing.current_process().name\n print(f\"{name} is preparing burger #{order_num}...\")\n time.sleep(5) # time for making burger\n item_made.put(f\"Burger #{order_num}\")\n print(f\"Burger #{order_num} made by {name}\")\n\n\n\n\ndef make_fries(order_num, item_made):\n name = multiprocessing.current_process().name\n print(f\"{name} is preparing fries #{order_num}...\")\n time.sleep(2) # time for making fries\n item_made.put(f\"Fries #{order_num}\")\n print(f\"Fries #{order_num} made by {name}\")\n\n\n\n\ndef working(task_queue, item_made, order_num, lock):\n break_count = 0\n name = multiprocessing.current_process().name\n while True:\n try:\n task = task_queue.get_nowait()\n except queue.Empty:\n print(f\"{name} has nothing to do...\")\n if break_count > 1:\n break # stop if idle for too long\n else:\n break_count += 1\n time.sleep(1)\n else:\n lock.acquire()\n try:\n current_num = order_num.value\n order_num.value = current_num + 1\n finally:\n lock.release()\n task(current_num, item_made)\n break_count = 0\n\n\n\n\nif __name__ == \"__main__\":\n\n\n print(\"Welcome to Pyburger! Please place your order.\")\n\n\n burger_num = input(\"Number of burgers:\")\n fries_num = input(\"Number of fries:\")\n\n\n s = time.perf_counter()\n\n\n task_queue = multiprocessing.Queue()\n item_made = multiprocessing.Queue()\n order_num = multiprocessing.Value(\"i\", 0)\n lock = multiprocessing.Lock()\n\n\n for i in range(int(burger_num)):\n task_queue.put(make_burger)\n for i in range(int(fries_num)):\n task_queue.put(make_fries)\n\n\n staff1 = multiprocessing.Process(\n target=working,\n name=\"John\",\n args=(\n task_queue,\n item_made,\n order_num,\n lock,\n ),\n )\n staff2 = multiprocessing.Process(\n target=working,\n name=\"Jane\",\n args=(\n task_queue,\n item_made,\n order_num,\n lock,\n ),\n )\n\n\n staff1.start()\n staff2.start()\n\n\n staff1.join()\n staff2.join()\n\n\n print(\"All tasks finished. Closing now.\")\n print(\"Items created are:\")\n\n\n while not item_made.empty():\n print(item_made.get())\n\n\n elapsed = time.perf_counter() - s\n\n\n print(f\"Orders completed in {elapsed:0.2f} seconds.\")\n<\/pre>\nEste es el resultado que obtenemos:<\/p>\n
Welcome to Pyburger! Please place your order.\nNumber of burgers:3\nNumber of fries:2\nJane has nothing to do...\nJohn is preparing burger #0...\nJane is preparing burger #1...\nBurger #0 made by John\nJohn is preparing burger #2...\nBurger #1 made by Jane\nJane is preparing fries #3...\nFries #3 made by Jane\nJane is preparing fries #4...\nBurger #2 made by John\nJohn has nothing to do...\nFries #4 made by Jane\nJane has nothing to do...\nJohn has nothing to do...\nJane has nothing to do...\nJohn has nothing to do...\nJane has nothing to do...\nAll tasks finished. Closing now.\nItems created are:\nBurger #0\nBurger #1\nFries #3\nBurger #2\nFries #4\nOrders completed in 12.21 seconds.\n<\/pre>\nTenga en cuenta que existen algunas limitaciones en el multiprocesamiento <\/em>que hacen que el c\u00f3digo anterior se haya dise\u00f1ado de esta forma. Vamos a repasarlas una por una.<\/p>\nEn primer lugar, recuerde que antes ten\u00edamos las funciones <\/em>make_burger y make_fries para generar una funci\u00f3n con el orden_num correcto:<\/p>\ndef make_burger(order_num):\n def making_burger():\n logger.info(f\"Preparing burger #{order_num}...\")\n time.sleep(5) # time for making burger\n logger.info(f\"Burger made #{order_num}\")\n\n\n return making_burger\n\n\n\n\ndef make_fries(order_num):\n def making_fries():\n logger.info(f\"Preparing fries #{order_num}...\")\n time.sleep(2) # time for making fries\n logger.info(f\"Fries made #{order_num}\")\n\n\n return making_fries\n<\/pre>\nNo podemos hacer lo mismo cuando utilizamos el multiprocesamiento. Si lo intentamos, obtendremos un error del tipo:<\/p>\n
AttributeError: Can't get local object 'make_burger..making_burger'<\/pre>\nLa raz\u00f3n es que el multiprocesamiento utiliza pickle<\/a>, que solo puede serializar funciones de nivel de m\u00f3dulo superior en general. Esta es una de las limitaciones del multiprocesamiento.<\/em><\/p>\nEn segundo lugar, observe que en el fragmento de c\u00f3digo del ejemplo anterior que utiliza el multiprocesamiento no utilizamos ninguna variable global para los datos compartidos. Por ejemplo, no podemos utilizar variables globales para item_made y order_num. Para compartir datos entre distintos procesos, se utilizan objetos de clase especial como <\/em>Queue y <\/em>Value de la biblioteca de multiprocesamiento y se pasan a los procesos como argumentos.
En general, no se recomienda compartir datos y estados entre distintos procesos, ya que puede causar muchos m\u00e1s problemas. En nuestro ejemplo anterior, tenemos que utilizar un bloqueo para asegurarnos de que solo puede acceder e incrementar el valor de order_num un proceso a la vez. Sin el bloqueo, el n\u00famero de pedido del art\u00edculo puede desordenarse as\u00ed:<\/p>\nItems created are:\n\nBurger #0\nBurger #0\nFries #2\nBurger #1\nFries #3\n<\/pre>\nAqu\u00ed tenemos c\u00f3mo utilizar un bloqueo para evitar problemas:<\/p>\n
lock.acquire()\n try:\n current_num = order_num.value\n order_num.value = current_num + 1\n finally:\n lock.release()\n task(current_num, item_made)\n<\/pre>\nPara saber m\u00e1s sobre c\u00f3mo utilizar la biblioteca est\u00e1ndar de multiprocesamiento, puede consultar la documentaci\u00f3n aqu\u00ed<\/a>.<\/p>\nEliminaci\u00f3n del GIL<\/h2>\n
La eliminaci\u00f3n del GIL ha sido un tema de debate durante casi una d\u00e9cada. En 2016, en el Python Language Summit, Larry Hastings present\u00f3 sus reflexiones sobre la realizaci\u00f3n de una \u00abGIL-ectom\u00eda\u00bb en el int\u00e9rprete CPython y los progresos que hab\u00eda hecho con esta idea [1]. Este fue un intento pionero de eliminar el GIL de Python. En 2021, Sam Gross reaviv\u00f3 la discusi\u00f3n sobre la eliminaci\u00f3n del GIL [2], y eso condujo a la publicaci\u00f3n de PEP 703 – Making the Global Interpreter Lock Optional in CPython<\/a> en 2023.<\/p>\nComo vemos, la supresi\u00f3n del GIL no es en absoluto una decisi\u00f3n precipitada y ha sido objeto de un amplio debate en la comunidad. Como demuestran los ejemplos anteriores de multiprocesamiento (y el PEP 703, enlazado m\u00e1s arriba), cuando se elimina la garant\u00eda proporcionada por el GIL, las cosas se complican r\u00e1pidamente.<\/p>\n
[1]: https:\/\/lwn.net\/Articles\/689548\/<\/a><\/p>\n[2]: https:\/\/lwn.net\/ml\/python-dev\/CAGr09bSrMNyVNLTvFq-h6t38kTxqTXfgxJYApmbEWnT71L74-g@mail.gmail.com\/<\/p>\n
Recuento de referencias<\/h3>\n
Cuando el GIL est\u00e1 presente, el recuento de referencias y la recogida de basura son m\u00e1s sencillos. Cuando solo un hilo a la vez tiene acceso a objetos Python, podemos confiar en un recuento de referencias<\/a> no at\u00f3mico directo y eliminar el objeto cuando el recuento de referencias llegue a cero.<\/p>\nLa eliminaci\u00f3n del GIL complica las cosas. Ya no podemos utilizar el recuento de referencias no at\u00f3mico, ya que no garantiza la seguridad de los hilos<\/a>. Las cosas pueden ir mal si varios hilos est\u00e1n realizando varios incrementos y decrementos de la referencia en el objeto Python al mismo tiempo. Lo ideal ser\u00eda utilizar el recuento at\u00f3mico de referencias para garantizar la seguridad de los hilos. Pero este m\u00e9todo adolece de una elevada sobrecarga y su eficacia se ve mermada cuando hay muchos hilos.<\/p>\nLa soluci\u00f3n es utilizar el recuento de referencias sesgado, que tambi\u00e9n garantiza la seguridad de los hilos. La idea es inclinar cada objeto hacia un hilo propietario, que es el hilo que accede a ese objeto la mayor parte del tiempo. Los hilos propietarios pueden realizar un recuento de referencias no at\u00f3mico en los objetos que poseen, mientras que los dem\u00e1s hilos deben realizar un recuento de referencias at\u00f3mico en esos objetos. Este m\u00e9todo es preferible al simple recuento at\u00f3mico de referencias, porque la mayor\u00eda de los objetos solo reciben acceso a un hilo la mayor parte del tiempo. Podemos reducir la sobrecarga de ejecuci\u00f3n permitiendo que el hilo propietario realice un recuento de referencias no at\u00f3mico.<\/p>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/07\/image-22.png\")
<\/figure>\nAdem\u00e1s, algunos objetos Python de uso com\u00fan, como True, False, <\/em>enteros peque\u00f1os y algunas cadenas internadas, se hacen inmortales. Aqu\u00ed, \u00abinmortal\u00bb solo significa que los objetos permanecer\u00e1n en el programa durante toda su vida \u00fatil, por lo que no requieren recuento de referencias.<\/p>\nRecolecci\u00f3n de basura<\/h3>\n
Tambi\u00e9n tenemos que modificar la forma en que se realiza la recolecci\u00f3n de basura<\/a>. En lugar de disminuir el recuento de referencias inmediatamente cuando se libera la referencia y eliminar el objeto enseguida cuando el recuento de referencias llega a cero, se utiliza una t\u00e9cnica denominada \u00abrecuento de referencias diferido\u00bb.\u00a0<\/p>\nCuando es necesario disminuir el recuento de referencias, el objeto se almacena en una tabla, que se comprobar\u00e1 dos veces para ver si esta disminuci\u00f3n en el recuento de referencias es exacta o no. Esto evita eliminar el objeto prematuramente cuando a\u00fan est\u00e1 siendo referenciado, lo que puede ocurrir sin el GIL, ya que el recuento de referencias no es tan sencillo como con el GIL. Esto complica el proceso de recolecci\u00f3n de basura, ya que esta puede necesitar atravesar la pila<\/a> de cada hilo para el recuento de referencias propio de cada hilo.<\/p>\nOtra cosa que tener en cuenta: el recuento de referencias debe ser estable durante la recolecci\u00f3n de basura. Si un objeto est\u00e1 a punto de ser descartado pero de repente se hace referencia a \u00e9l, esto causar\u00e1 graves problemas. Por ello, durante el ciclo de recolecci\u00f3n de basura, tendr\u00e1 que \u00abparar el mundo\u00bb para ofrecer garant\u00edas de seguridad de los hilos.<\/p>\n
Asignaci\u00f3n de memoria<\/h3>\n
Cuando existe el GIL para garantizar la seguridad de los hilos, se utiliza el asignador de memoria interno de Python pymalloc. Pero sin el GIL, necesitaremos un nuevo asignador de memoria. Sam Gross propuso mimalloc<\/a> en el PEP, que es un asignador de uso general creado por Daan Leijen y mantenido por Microsoft. Es una buena elecci\u00f3n, porque es seguro para los hilos y tiene un buen rendimiento en objetos peque\u00f1os.<\/p>\nMimalloc llena su mont\u00f3n con p\u00e1ginas y las p\u00e1ginas con bloques.<\/em> Cada p\u00e1gina contiene bloques, y los bloques <\/em>dentro de cada p\u00e1gina tienen todos el mismo tama\u00f1o. Al a\u00f1adir algunas restricciones al acceso a la lista y al diccionario, el recolector de basura no tiene que mantener una lista vinculada<\/a> para encontrar todos los objetos, y tambi\u00e9n permite el acceso de lectura a la <\/em>lista y al diccionario sin adquirir el bloqueo.<\/p>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/07\/image-23.png\")
<\/figure>\nHay m\u00e1s detalles sobre la eliminaci\u00f3n del GIL, pero es imposible abarcarlos todos aqu\u00ed. Puede consultar PEP 703 \u2013 Making the Global Interpreter Lock Optional in CPython<\/a> para ver un desglose completo.<\/p>\nDiferencia de rendimiento con el GIL y sin \u00e9l<\/h2>\n
Como Python 3.13 proporciona una opci\u00f3n de hilo libre, podemos comparar el rendimiento de la versi\u00f3n est\u00e1ndar de Python 3.13 con la versi\u00f3n de hilo libre.<\/p>\n
Instalar Python con hilos libres<\/h3>\n
Utilizaremos pyenv<\/a> para instalar ambas versiones: la est\u00e1ndar (por ejemplo, 3.13.5) y la versi\u00f3n con hilos libres (por ejemplo, 3.13.5t).\u00a0<\/p>\nTambi\u00e9n puede utilizar los instaladores de Python.org<\/a>. Aseg\u00farese de seleccionar la opci\u00f3n Customize<\/em> durante la instalaci\u00f3n y marque la casilla adicional para instalar Python con hilos libres (consulte el ejemplo de este art\u00edculo del blog<\/a>).<\/p>\nDespu\u00e9s de instalar ambas versiones, podemos a\u00f1adirlas como int\u00e9rpretes en un proyecto PyCharm.<\/p>\n
En primer lugar, haga clic en el nombre de su int\u00e9rprete de Python en la parte inferior derecha.<\/p>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/07\/image-24.png\")
<\/figure>\nSeleccione Add New Interpreter<\/em> en el men\u00fa y, despu\u00e9s, Add Local Interpreter<\/em>.<\/p>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/07\/image-25.png\")
<\/figure>\nElija Select existing<\/em>, espere a que se cargue la ruta del int\u00e9rprete (lo que puede tardar un rato si tiene muchos int\u00e9rpretes como yo) y, a continuaci\u00f3n, seleccione el nuevo int\u00e9rprete que acaba de instalar en el men\u00fa desplegable Python path<\/em>.<\/p>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/07\/image-26.png\")
<\/figure>\nPulse OK<\/em> para a\u00f1adirlo. Repita los mismos pasos para el otro int\u00e9rprete. Ahora, cuando vuelva a hacer clic en el nombre del int\u00e9rprete en la parte inferior derecha, ver\u00e1 varios int\u00e9rpretes de Python 3.13, como en la imagen de arriba.<\/p>\nPruebas con un proceso limitado por la CPU<\/h3>\n
A continuaci\u00f3n, necesitamos un script para probar las diferentes versiones. Recuerde que en la parte 1 de esta serie de art\u00edculos del blog<\/a> explicamos que para acelerar los procesos limitados por la CPU necesitamos un verdadero multihilo. Para ver si la eliminaci\u00f3n del GIL permitir\u00e1 un verdadero multihilo y har\u00e1 que Python sea m\u00e1s r\u00e1pido, podemos hacer una prueba con un proceso limitado por la CPU en varios hilos. Aqu\u00ed est\u00e1 el guion que le ped\u00ed a Junie<\/a> que generara (con algunos ajustes finales por mi parte):<\/p>\nimport time\nimport multiprocessing # Kept for CPU count\nfrom concurrent.futures import ThreadPoolExecutor\nimport sys\n\n\n\n\ndef is_prime(n):\n \"\"\"Check if a number is prime (CPU-intensive operation).\"\"\"\n if n <= 1:\n return False\n if n <= 3:\n return True\n if n % 2 == 0 or n % 3 == 0:\n return False\n i = 5\n while i * i <= n:\n if n % i == 0 or n % (i + 2) == 0:\n return False\n i += 6\n return True\n\n\n\n\ndef count_primes(start, end):\n """Count prime numbers in a range."""\n count = 0\n for num in range(start, end):\n if is_prime(num):\n count += 1\n return count\n\n\n\n\ndef run_single_thread(range_size, num_chunks):\n """Run the prime counting task in a single thread."""\n chunk_size = range_size \/\/ num_chunks\n total_count = 0\n\n\n start_time = time.time()\n\n\n for i in range(num_chunks):\n start = i * chunk_size + 1\n end = (i + 1) * chunk_size + 1 if i < num_chunks - 1 else range_size + 1\n total_count += count_primes(start, end)\n\n\n end_time = time.time()\n\n\n return total_count, end_time - start_time\n\n\n\n\ndef thread_task(start, end):\n """Task function for threads."""\n return count_primes(start, end)\n\n\n\n\ndef run_multi_thread(range_size, num_threads, num_chunks):\n """Run the prime counting task using multiple threads."""\n chunk_size = range_size \/\/ num_chunks\n total_count = 0\n\n\n start_time = time.time()\n\n\n with ThreadPoolExecutor(max_workers=num_threads) as executor:\n futures = []\n for i in range(num_chunks):\n start = i * chunk_size + 1\n end = (i + 1) * chunk_size + 1 if i < num_chunks - 1 else range_size + 1\n futures.append(executor.submit(thread_task, start, end))\n\n\n for future in futures:\n total_count += future.result()\n\n\n end_time = time.time()\n\n\n return total_count, end_time - start_time\n\n\n\n\ndef main():\n # Fixed parameters\n range_size = 1000000 # Range of numbers to check for primes\n num_chunks = 16 # Number of chunks to divide the work into\n num_threads = 4 # Fixed number of threads for multi-threading test\n\n\n print(f"Python version: {sys.version}")\n print(f"CPU count: {multiprocessing.cpu_count()}")\n print(f"Range size: {range_size}")\n print(f"Number of chunks: {num_chunks}")\n print("-" * 60)\n\n\n # Run single-threaded version as baseline\n print("Running single-threaded version (baseline)...")\n count, single_time = run_single_thread(range_size, num_chunks)\n print(f"Found {count} primes in {single_time:.4f} seconds")\n print("-" * 60)\n\n\n # Run multi-threaded version with fixed number of threads\n print(f"Running multi-threaded version with {num_threads} threads...")\n count, thread_time = run_multi_thread(range_size, num_threads, num_chunks)\n speedup = single_time \/ thread_time\n print(f"Found {count} primes in {thread_time:.4f} seconds (speedup: {speedup:.2f}x)")\n print("-" * 60)\n\n\n # Summary\n print("SUMMARY:")\n print(f"{'Threads':<10} {'Time (s)':<12} {'Speedup':<10}")\n print(f"{'1 (baseline)':<10} {single_time:<12.4f} {'1.00x':<10}")\n print(f"{num_threads:<10} {thread_time:<12.4f} {speedup:.2f}x")\n\n\nif __name__ == "__main__":\n main()\n<\/pre>\nPara facilitar la ejecuci\u00f3n del script con diferentes int\u00e9rpretes de Python, podemos a\u00f1adir un script de ejecuci\u00f3n personalizado a nuestro proyecto PyCharm.<\/p>\n
En la parte superior, seleccione Edit Configurations\u2026<\/em> en el men\u00fa desplegable situado junto al bot\u00f3n Run<\/em> (![](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/10\/AD_4nXcRz0HogcsseQcC85-vSwRJhBWhiZCysBUZjcuu1uQYusTx-hj6h-l4FAs_HUE1gcJV5kjSjPuUu1opfKgu6sH5G9epkDlMMw0fBRPyReunr-DgSpg5O_6QTIYROqOaiMHGAX42vg.png\")
).<\/p>\n![](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/10\/AD_4nXeLJtj8xjnN-WQM7UQAop3RCg1hSElHa9WqFMBgXWGyxaxg07kOEhYnBV2i1WOnw5fUB_LsN-QWXidRJ-WMUVAkjF9aSVws684Jbnnoc8P-t_EDD622RghKpL5LjckKoKf251If3A.png\")
<\/p>\n
Haga clic en el bot\u00f3n + de la parte superior izquierda y elija Python en el men\u00fa desplegable Add New Configuration<\/em>.<\/p>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/07\/image-27.png\")
<\/figure>\nElija un nombre que le permita saber qu\u00e9 int\u00e9rprete concreto se est\u00e1 utilizando, por ejemplo, 3.13.5 frente a 3.15.3t. Elija el int\u00e9rprete adecuado y a\u00f1ada el nombre del script de prueba de esta forma:<\/p>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/07\/image-28.png\")
<\/figure>\nA\u00f1ada dos configuraciones, una para cada int\u00e9rprete. A continuaci\u00f3n, pulse OK<\/em>.<\/p>\nAhora podemos seleccionar y ejecutar f\u00e1cilmente el script de prueba con el GIL o sin \u00e9l, seleccionando la configuraci\u00f3n y haciendo clic en el bot\u00f3n Run<\/em> () de la parte superior.<\/p>\nComparaci\u00f3n de los resultados<\/h3>\n
Este es el resultado que obtuve al ejecutar la versi\u00f3n est\u00e1ndar 3.13.5 con el GIL:<\/p>\n
Python version: 3.13.5 (main, Jul 10 2025, 20:33:15) [Clang 17.0.0 (clang-1700.0.13.5)]\nCPU count: 8\nRange size: 1000000\nNumber of chunks: 16\n------------------------------------------------------------\nRunning single-threaded version (baseline)...\nFound 78498 primes in 1.1930 seconds\n------------------------------------------------------------\nRunning multi-threaded version with 4 threads...\nFound 78498 primes in 1.2183 seconds (speedup: 0.98x)\n------------------------------------------------------------\nSUMMARY:\nThreads Time (s) Speedup \n1 (baseline) 1.1930 1.00x \n4 1.2183 0.98x\n<\/pre>\nComo puede ver, no hay ning\u00fan cambio significativo en la velocidad cuando se ejecuta la versi\u00f3n con 4 hilos en comparaci\u00f3n con la referencia de un solo hilo. Veamos qu\u00e9 obtenemos al ejecutar la versi\u00f3n con hilos libres 3.13.5t:<\/p>\n
Python version: 3.13.5 experimental free-threading build (main, Jul 10 2025, 20:36:28) [Clang 17.0.0 (clang-1700.0.13.5)]\nCPU count: 8\nRange size: 1000000\nNumber of chunks: 16\n------------------------------------------------------------\nRunning single-threaded version (baseline)...\nFound 78498 primes in 1.5869 seconds\n------------------------------------------------------------\nRunning multi-threaded version with 4 threads...\nFound 78498 primes in 0.4662 seconds (speedup: 3.40x)\n------------------------------------------------------------\nSUMMARY:\nThreads Time (s) Speedup \n1 (baseline) 1.5869 1.00x \n4 0.4662 3.40x\n<\/pre>\nEsta vez, la velocidad fue m\u00e1s de 3 veces superior. Observe que en ambos casos existe una sobrecarga por multihilo. Por lo tanto, incluso con un verdadero multihilo, la velocidad no es 4 veces mayor con 4 hilos.<\/p>\n
Conclusi\u00f3n<\/h2>\n
En la parte 2 de la serie de art\u00edculos del blog Faster Python, hablamos de la raz\u00f3n de tener el GIL de Python en el pasado, de sortear la limitaci\u00f3n del GIL utilizando el multiprocesamiento, y del proceso y efecto de eliminar el GIL.<\/p>\n
En el momento de publicar este art\u00edculo, la versi\u00f3n de Python con hilos libres a\u00fan no es la predeterminada. Sin embargo, con la adopci\u00f3n de la comunidad y de las bibliotecas de terceros, la comunidad espera que la versi\u00f3n de Python con hilos libres sea el est\u00e1ndar en el futuro. Se ha anunciado que Python 3.14 incluir\u00e1 una versi\u00f3n con hilos libres que habr\u00e1 superado la fase experimental, pero que seguir\u00e1 siendo opcional.<\/p>\n
![\"Cheuk](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/01\/CheukTingHo-Kimono-e1738750639162-200x200.jpg\")
\n <\/div>\n