← Volver a los ejercicios

Por qué el padre no ve lo que escribió el hijo

El ejemplo de la lista global: diga qué imprime cada proceso antes de destapar la salida, y después cambie el escenario para ver qué llega al padre cuando el dato va en un argumento, en un multiprocessing.Array o en un Manager. Luego recorra paso a paso lo que ocurre al crear un hijo con fork, forkserver y spawn, y decida por qué un programa que anda en Linux se cae en Windows.

1. El ejemplo de la lista global

1import multiprocessing
2
3resultado = [] # Variable global
4
5def cuadrados(lista):
6 global resultado
7 for num in lista:
8 resultado.append(num * num)
9 print("Resultado en p1: {}".format(resultado))
10
11if __name__ == "__main__":
12 lista = [1, 2, 3, 4]
13 p1 = multiprocessing.Process(target=cuadrados, args=(lista,))
14 p1.start()
15 p1.join()
16
17 print("Resultado en el programa principal: {}".format(resultado))

¿Qué imprime el programa?

El print del hijo sale antes del join; el del padre, después. Los dos leen una variable que se llama resultado, y no es la misma.

2. Dos espacios de memoria

Array y Value aceptan tipos simples de C ('i' entero, 'd' doble, 'l' largo) y viven en un bloque que el sistema operativo mapea en todos los procesos. shared_memory reserva un bloque de bytes con nombre que cualquier proceso abre e interpreta como quiera, por ejemplo como un arreglo de NumPy. Un Manager guarda objetos de Python completos y cobra un viaje al proceso servidor por cada acceso.

3. Cómo arranca un hijo

Con spawn y forkserver el módulo se vuelve a importar en cada hijo. Todo lo que esté escrito fuera de if __name__ == "__main__": se ejecuta otra vez, y si allí se crean procesos, se crean sin fin.

4. Qué se hereda en cada modo

ModoVariable globalArgumento pasado a Processmultiprocessing.Array

Un programa funciona en Linux leyendo una variable global desde el hijo y falla en Windows. ¿Por qué?

fork existe solo en Unix. forkserver es el modo por defecto en Linux desde Python 3.14. spawn es lo único que hay en Windows y macOS, y se puede fijar a mano con multiprocessing.set_start_method("spawn") para probar en Linux lo que va a pasar allá.

5. Array y Value no eximen de sincronizar

1def acumular(ini, fin, total):
2 parcial = 0
3 for i in range(ini, fin):
4 parcial += i
5 total.value += parcial # cuatro procesos, el mismo Value

Cuatro procesos suman sobre el mismo multiprocessing.Value y el total sale mal. ¿Qué falta?

En la suma paralela por segmentos no aparece este problema: cada proceso escribe en su propio Value (v1, v2, v3, v4) y el padre combina los cuatro cuando todos terminaron. Con dos escritores sobre una misma posición hay dos salidas: repartir en segmentos disjuntos o proteger la actualización.