Hilos

Ejercicios

• Contador Concurrente
  • Escribe un programa que utilice dos hilos para incrementar y decrementar un contador compartido. Asegúrate de manejar adecuadamente la exclusión mutua para evitar condiciones de carrera.
• Imprimir en Orden
  • Crea tres hilos que impriman “Uno”, “Dos” y “Tres”, respectivamente, en orden. Asegúrate de que cada hilo espere al hilo anterior antes de imprimir su número.
• Productor-Consumidor
  • Implementa un problema de productor-consumidor utilizando dos hilos productores y dos hilos consumidores. Utiliza una cola compartida para la comunicación entre productores y consumidores.

Codificación

Solución 1: Contador Concurrente en Python

import threading
import time

contador = 0
mutex = threading.Lock()

def incrementar():
    global contador
    for _ in range(1000000):
        with mutex:
            contador += 1

def decrementar():
    global contador
    for _ in range(1000000):
        with mutex:
            contador -= 1

# Crear hilos
hilo_incrementar = threading.Thread(target=incrementar)
hilo_decrementar = threading.Thread(target=decrementar)

# Iniciar hilos
hilo_incrementar.start()
hilo_decrementar.start()

# Esperar a que ambos hilos terminen
hilo_incrementar.join()
hilo_decrementar.join()

print("Valor final del contador:", contador)

Explicación

• Se utiliza un contador compartido (contador) que dos hilos (incrementar y decrementar) modifican simultáneamente.
• Se utiliza un cerrojo (mutex) para garantizar la exclusión mutua y evitar condiciones de carrera.
• Cada hilo realiza un millón de incrementos o decrementos dentro de la sección crítica (dentro del with mutex).
• Al final, se imprime el valor final del contador.

Solución 2: Imprimir en Orden en Python

import threading

def imprimir_uno():
    print("Uno")

def imprimir_dos():
    print("Dos")

def imprimir_tres():
    print("Tres")

# Crear hilos
hilo_uno = threading.Thread(target=imprimir_uno)
hilo_dos = threading.Thread(target=imprimir_dos)
hilo_tres = threading.Thread(target=imprimir_tres)

# Iniciar hilos en orden
hilo_uno.start()
hilo_uno.join()

hilo_dos.start()
hilo_dos.join()

hilo_tres.start()
hilo_tres.join()

Explicación

• Se crean tres funciones (imprimir_uno, imprimir_dos, imprimir_tres) que imprimen diferentes mensajes.
• Se crean tres hilos (hilo_uno, hilo_dos, hilo_tres) asociados a cada función.
• Los hilos se inician y se espera a que cada uno termine antes de iniciar el siguiente, garantizando que los mensajes se impriman en orden.

Solución 3: Problema de Productor-Consumidor en Python

import threading
import queue
import time
import random

cola = queue.Queue(maxsize=5)

def productor():
    for i in range(5):
        item = f"Elemento-{i}"
        cola.put(item)
        print(f"Productor produce: {item}")
        time.sleep(random.uniform(0.1, 0.5))

def consumidor():
    while True:
        item = cola.get()
        print(f"Consumidor consume: {item}")
        time.sleep(random.uniform(0.2, 0.7))

# Crear hilos
hilo_productor_1 = threading.Thread(target=productor)
hilo_productor_2 = threading.Thread(target=productor)
hilo_consumidor_1 = threading.Thread(target=consumidor)
hilo_consumidor_2 = threading.Thread(target=consumidor)

# Iniciar hilos
hilo_productor_1.start()
hilo_productor_2.start()
hilo_consumidor_1.start()
hilo_consumidor_2.start()

Explicación

• Se utiliza una cola (cola) para la comunicación entre productores y consumidores.
• Hay dos thread productores (hilo_productor_1 y hilo_productor_2) y dos thread consumidores (hilo_consumidor_1 y hilo_consumidor_2).
• Los productores ponen elementos en la cola, mientras que los consumidores los sacan y los imprimen.
• El programa sigue ejecutándose indefinidamente, y los thread se pueden interrumpir manualmente.