Summary
This chapter covers creating and managing threads using Python’s threading module—including starting, joining, and synchronizing access to shared data with locks to prevent race conditions.

General domain of usage
I/O-bound operations


Imagine a kitchen as your Python process: it's the environment where all the action happens. Inside this kitchen, chefs represent threads—each chef is a worker, carrying out specific tasks. The fridge and counter are like your shared memory (RAM), where all chefs can reach for ingredients or place finished dishes. This is how threads in Python share data—they all work in the same space and can access the same resources.

When you run multiple threads, it's like having a team of chefs in the same kitchen. If one chef is waiting for the oven (an I/O bound operation), another can chop vegetables or start a new dish. This is concurrency: tasks overlap in time, making the kitchen more efficient.

However, there's a special rule in Python called the Global Interpreter Lock, or GIL. Think of the GIL as the 'Master Knife'—only one chef can use it at any moment. Chefs must pass the knife between them quickly, so it looks like they're all working at once. In reality, only one chef is actively preparing food with the knife at any given time. This means threads take turns running Python code, even though they share the kitchen.

Let's tie this back to the threading code example. When you create two threads, it's like hiring two chefs. Each chef has a name, so you can tell who is doing what. The 'start' method signals both chefs to begin working, and 'join' waits for both to finish before you close the kitchen. If both chefs need the fridge at the same time, you use a lock—like a kitchen rule—to make sure they don't collide or spoil the ingredients. This way, your kitchen (process) stays organized, and your chefs (threads) can work together safely and efficiently.. In video use code samples with 9 code lines maximum and one sample at each slide.

El módulo `threading` de Python proporciona una forma sencilla pero potente de crear y gestionar hilos, lo que permite ejecutar múltiples operaciones de manera concurrente dentro de un solo proceso. Los hilos son unidades ligeras de ejecución que comparten el mismo espacio de memoria, lo que los hace adecuados para tareas como operaciones de entrada/salida, espera de recursos externos o actualización de interfaces de usuario.

El ciclo de vida de un hilo normalmente implica varias etapas:  
- Creación: se instancia un objeto hilo pero aún no se inicia;  
- Inicio: se llama al método `start()` del hilo, pasando al estado listo para ejecutarse;  
- Ejecución: el hilo ejecuta su función objetivo;  
- Terminación: el hilo finaliza su ejecución, ya sea completando su tarea o al encontrar una excepción no controlada.



La gestión de hilos requiere especial atención a la **sincronización**, ya que los hilos comparten datos y recursos. Sin una sincronización adecuada, pueden producirse **condiciones de carrera** o estados inconsistentes. El módulo `threading` ofrece primitivas como `Lock`, `RLock` y `Event` para ayudar a coordinar el acceso de los hilos a los recursos compartidos.

 

A continuación se muestra una tabla con funciones que te ayudarán a crear, gestionar y sincronizar hilos de manera eficaz al trabajar con tareas concurrentes en Python.

Creates a new thread object; pass a target function and arguments.

Begins execution of the thread; runs the target function in a new thread. 

Waits for the thread to finish before continuing execution.

Adds a thread object to a list; used to collect multiple threads so they can be managed as a group.

Returns the currently executing thread object. 

Creates a lock object for synchronizing access to shared resources.

Creates a re-entrant lock, allowing the same thread to acquire it multiple times.

Creates an event object for signaling between threads.

Sets or gets the thread's name for easier identification


El siguiente ejemplo demuestra cómo puedes crear e iniciar múltiples hilos utilizando el módulo `threading`, permitiendo que varias tareas se ejecuten de forma concurrente.

import threading
import time

def print_numbers(name):
    for i in range(1, 4):
        print(f"Thread {name}: {i}")
        time.sleep(0.5)

# Create thread objects
thread1 = threading.Thread(target=print_numbers, args=("A",))
thread2 = threading.Thread(target=print_numbers, args=("B",))

# Start the threads
thread1.start()
thread2.start()

# Wait for both threads to finish
thread1.join()
thread2.join()

print("Both threads have finished.")

Se define una función, `print_numbers`, que imprime una secuencia de números junto con el nombre del hilo. Al crear cada hilo, se pasan argumentos utilizando el parámetro `args`; en este caso, cada hilo recibe un nombre diferente ("A" o "B") para distinguir fácilmente sus salidas. Al llamar al método `start()`, ambos hilos comienzan su ejecución y se ejecutan de manera concurrente. La llamada a `time.sleep(0.5)` dentro del bucle simula una demora en la ejecución, lo que permite que los hilos entrelacen sus salidas y facilita observar que ambos hilos están funcionando al mismo tiempo. Luego, se utiliza el método `join()` para esperar a que ambos hilos finalicen antes de continuar, asegurando que el programa principal no termine prematuramente. Este enfoque permite que las tareas se ejecuten en paralelo, aprovechando eficientemente los tiempos de espera y habilitando la ejecución concurrente dentro de un solo proceso.

¿Cuál de las siguientes afirmaciones sobre la sincronización de hilos en Python es correcta?

Un análisis profundo de conceptos avanzados de programación estructural en Python, enfocado en el manejo robusto de archivos, gestión de errores, concurrencia, programación asíncrona y pruebas.

Domina el sistema de excepciones de Python para un manejo de errores y depuración robustos.

Explora técnicas avanzadas para operaciones de archivos y gestión de recursos utilizando gestores de contexto.

Comparación y aplicación de los módulos de multithreading y multiprocessing de Python para la programación concurrente.

Domina la programación asíncrona en Python utilizando la biblioteca asyncio para aplicaciones escalables dependientes de E/S.

Explora cómo escribir, organizar y ejecutar pruebas utilizando los frameworks unittest y pytest de Python.

Trabajando con Hilos