47. Control de vitrocerámica

Crea un sistema simple para controlar el estado de una "vitrocerámica" con múltiples "fuegos" o zonas de cocción, cada una con su propio nivel de potencia. La clave es que cada fuego pueda ser controlado de manera independiente, posiblemente en paralelo.

Representa la vitrocerámica como una estructura de datos (por ejemplo, una lista de diccionarios, donde cada diccionario representa un fuego y tiene propiedades como id, potencia, encendido). Crea funciones para:

• encender_fuego(id_fuego, potencia): Enciende un fuego con una potencia dada (0-10).

• apagar_fuego(id_fuego): Apaga un fuego.

• obtener_estado_fuegos(): Devuelve el estado actual de todos los fuegos.

Las operaciones de encendido y apagado deben poder ejecutarse de forma concurrente sin interferir entre sí.

import threading # O multiprocessing

# Estado global (se necesitará un Lock si se usa threading para modificarlo)
vitrocerámica_estado = [] # Por ejemplo: [{"id": 1, "potencia": 0, "encendido": False}, ...]

def inicializar_vitrocerámica(num_fuegos: int) -> list[dict]:
    # Crea la estructura inicial de la vitrocerámica
    return [{"id": i + 1, "potencia": 0, "encendido": False} for i in range(num_fuegos)]

def encender_fuego(fuegos: list[dict], id_fuego: int, potencia: int) -> list[dict]:
    # Devuelve una NUEVA lista de fuegos con el fuego especificado actualizado
    # Asegúrate de que 0 <= potencia <= 10
    pass

def apagar_fuego(fuegos: list[dict], id_fuego: int) -> list[dict]:
    # Devuelve una NUEVA lista de fuegos con el fuego especificado apagado
    pass

def obtener_estado_fuegos(fuegos: list[dict]) -> list[dict]:
    # Devuelve el estado actual de los fuegos
    return fuegos

# Ejemplo de uso (simulando operaciones concurrentes)
# vitro_actual = inicializar_vitrocerámica(3)
#
# def operacion_fuego(id_fuego, potencia=None, apagar=False):
#    nonlocal vitro_actual # Para poder modificar vitro_actual en un hilo
#    if apagar:
#        vitro_actual = apagar_fuego(vitro_actual, id_fuego)
#    else:
#        vitro_actual = encender_fuego(vitro_actual, id_fuego, potencia)
#    print(f"Estado tras operación en fuego {id_fuego}: {obtener_estado_fuegos(vitro_actual)}")
#
# # Lanzar operaciones concurrentes
# hilo1 = threading.Thread(target=operacion_fuego, args=(1, 5))
# hilo2 = threading.Thread(target=operacion_fuego, args=(2, 8))
# hilo3 = threading.Thread(target=operacion_fuego, args=(1, None, True))
#
# hilo1.start()
# hilo2.start()
# hilo3.start()
#
# hilo1.join()
# hilo2.join()
# hilo3.join()
#
# print(f"Estado final de la vitrocerámica: {obtener_estado_fuegos(vitro_actual)}")

Ratoncito

Implementa las funciones inicializar_vitrocerámica, encender_fuego y apagar_fuego. Para manejar el estado compartido en un entorno multihilo, utiliza un mecanismo de bloqueo (Lock, RLock, Semaphore) para proteger el acceso a la lista de fuegos si los hilos la modifican directamente, o asegura que las funciones devuelvan nuevas estructuras de datos para mantener la inmutabilidad (el enfoque preferido de tu libro).

Dragón

Añade funcionalidades más avanzadas:

• Control de temperatura en lugar de solo potencia (simulando un incremento o decremento gradual).

• Implementa la gestión de la concurrencia de forma más robusta, por ejemplo, usando Queue o Event para que los hilos se comuniquen y coordinen las operaciones en los fuegos.

• Considera la posibilidad de que un fuego se "apague automáticamente" después de un tiempo si no se le presta atención.