A3 · Ejercicios de concurrencia y asincronía¶
Practica tareas simultáneas, resultados y errores, límites de tiempo, reintentos y datos compartidos. Cada ejercicio indica la salida esperada. Las esperas son de decenas de milisegundos, así que los resultados son siempre los mismos.
Ejercicio A3.1¶
Tres descargas a la vez. Simula tres descargas con una pausa cada una: uno (200 ms), dos (50 ms) y tres (100 ms). Cada descarga imprime termina <nombre> al acabar.
Lánzalas todas a la vez, espera a que terminen y comprueba que el conjunto tardó menos de 350 ms (si fueran una tras otra tardarían unos 350 ms o más). Imprime todas a la vez: sí o todas a la vez: no.
Salida esperada:
termina dos
termina tres
termina uno
todas a la vez: sí
En Python
Usa asyncio.sleep y asyncio.gather(...). Con time.sleep no habría concurrencia: bloquearía todo el programa.
Solución modelo (bloqueada)
🔒 La solución completa está bloqueada. Esto es solo un ejemplo de cómo empieza:
import asyncio
import time
async def descarga(nombre, ms):
await asyncio.sleep(ms / 1000)
print(f"termina {nombre}")
# ... (resto de la solución bloqueado)Ejercicio A3.2¶
Sumar en paralelo. Reparte la suma de los números del 1 al 100 entre dos tareas que trabajan a la vez: una suma del 1 al 50 y la otra del 51 al 100. Espera las dos y muestra la suma total.
Salida esperada:
5050
En Python
concurrent.futures.ThreadPoolExecutor y submit(...); future.result() recoge el valor. Para cálculo pesado de verdad, por el GIL, haría falta ProcessPoolExecutor.
Solución modelo (bloqueada)
🔒 La solución completa está bloqueada. Esto es solo un ejemplo de cómo empieza:
from concurrent.futures import ThreadPoolExecutor
def sumar(desde, hasta):
return sum(range(desde, hasta + 1))
with ThreadPoolExecutor(max_workers=2) as grupo:
primera = grupo.submit(sumar, 1, 50)
# ... (resto de la solución bloqueado)Ejercicio A3.3¶
Con límite de tiempo. Escribe una función asíncrona consulta(ms) que espere ms milisegundos y devuelva 42. Después escribe intentar(ms, limiteMs), que espera el resultado de la consulta como máximo limiteMs milisegundos: si llega a tiempo imprime resultado: 42, y si no, imprime tiempo agotado.
Pruébala con intentar(300, 100) y con intentar(50, 200).
Salida esperada:
tiempo agotado
resultado: 42
En Python
asyncio.wait_for(corrutina, segundos) lanza asyncio.TimeoutError si se pasa el tiempo (el límite va en segundos).
Solución modelo (bloqueada)
🔒 La solución completa está bloqueada. Esto es solo un ejemplo de cómo empieza:
import asyncio
async def consulta(ms):
await asyncio.sleep(ms / 1000)
return 42
async def intentar(ms, limite_ms):
# ... (resto de la solución bloqueado)Ejercicio A3.4¶
Reintentos. Escribe una operación asíncrona que falle las dos primeras veces que se llama y funcione la tercera (devolviendo el texto listo). Escribe conReintentos(maximo), que llama a la operación y, si falla, la repite hasta maximo veces en total.
En cada intento imprime intento N falló o intento N correcto; al final, resultado: listo. Prueba con un máximo de 3.
Salida esperada:
intento 1 falló
intento 2 falló
intento 3 correcto
resultado: listo
Solución modelo (bloqueada)
🔒 La solución completa está bloqueada. Esto es solo un ejemplo de cómo empieza:
import asyncio
llamadas = 0
async def operacion():
global llamadas
await asyncio.sleep(0.01)
# ... (resto de la solución bloqueado)Ejercicio A3.5¶
Un contador compartido, bien protegido. Lanza 5 tareas que suman 200 veces cada una a un mismo contador, y muestra el valor final (siempre 1000).
Hazlo de forma que no se pierda ninguna suma aunque las tareas se ejecuten a la vez.
Salida esperada:
1000
En Python
Un threading.Lock con with candado: alrededor de la suma.
Solución modelo (bloqueada)
🔒 La solución completa está bloqueada. Esto es solo un ejemplo de cómo empieza:
import threading
contador = 0
candado = threading.Lock()
def sumar_doscientos():
global contador
# ... (resto de la solución bloqueado)Ejercicio A3.6¶
Productor y consumidor. Un productor envía los números del 1 al 5 y un consumidor los va recibiendo y sumando. Se comunican por un canal (cola, stream...), no por una variable compartida. Cuando el productor termina, avisa de que no hay más.
Muestra solo la suma final.
Salida esperada:
suma: 15
En Python
Una asyncio.Queue entre dos corrutinas; None puede indicar «fin».
Solución modelo (bloqueada)
🔒 La solución completa está bloqueada. Esto es solo un ejemplo de cómo empieza:
import asyncio
FIN = None
async def productor(cola):
for i in range(1, 6):
await cola.put(i)
# ... (resto de la solución bloqueado)