¿Por qué la lectura no es segura para subprocesos?

Question

Me preguntaba por qué leer desde la memoria no es seguro para subprocesos. Entre lo que he visto hasta ahora, inter alia this pregunta, leer de la memoria no parece ser seguro para subprocesos.

He estado codificando en Python por un tiempo y ahora estoy entrando en C++. Nunca escuché que leer en Python no es seguro para subprocesos.

Corrígeme si me equivoco, pero si no, por favor dígame por qué leer de memoria no es seguro para subprocesos.

Answer 1

La lectura es segura para hilos, no hay problema ..... hasta que algo se escriba en la ubicación desde la que está leyendo, y luego ... bueno, con suerte leerá antes de que se cambien los datos, o leerá después del los datos se cambiaron (en estos casos, no hay preocupaciones), pero a veces, justo cuando realmente no lo desea, leerá a mitad de camino a través de la escritura y luego obtendrá datos de basura de competencia.

La forma de mitigar esto es asegurarse de que solo lee antes o después de cualquier escritura, lo que requiere que compruebe que se está produciendo una escritura y, por lo tanto, utilice un bloqueo de sincronización de algún tipo. Sin embargo, esto hace las cosas más lentas, ya que obviamente estás mirando el candado y luego leyendo en lugar de leer. Si está trabajando con tipos de datos primitivos (por ejemplo, una int), puede usar una sincronización de CPU para acelerar esto de manera espectacular.

Como en Python, lo más probable es que los datos de python siempre estén sincronizados para usted en el tiempo de ejecución del idioma; si no lo está, tarde o temprano obtendrá los mismos problemas de lectura de subprocesos. (Google rápido dice que sí, Python will suffer the same problems es que no tiene cuidado)

Answer 2

Es seguro para subprocesos si muchos subprocesos están leyendo la misma ubicación, hasta que nadie intenta escribir allí.

Considere si el hilo A está leyendo algo al mismo tiempo que el hilo B está escribiendo en la memoria que está leyendo. Generará un race condition. El resultado de la lectura puede no ser válido o diferente del inicio del lanzamiento

Answer 3

La lectura de la memoria es segura para la ejecución de subprocesos, aunque la lectura de la memoria que se puede escribir al mismo tiempo no es segura.

En Python esto es un problema menor ya que muchos objetos son inmutables, por lo tanto, solo se modifican las referencias en esos casos, no la memoria en sí misma.

Answer 4

Leer lo mismo simultáneamente - es seguro. El problema es cuando algo escribe en él al mismo tiempo.

considere el siguiente código:

int arr_len = 3; 
int* arr = new int[arr_len]; 

void thread_1() 
{ 
    std::cout << arr[arr_len-1]; 
} 

void thread_2(int new_len) 
{ 
    int* temp = new int[new_len]; 
    for(int i = 0; i < arr_len && i < new_len; ++i) 
     temp[i] = arr[i]; 
    arr_len = new_len; 
    delete arr; 
    arr = temp; 
} 

Supongamos que arr[arr_len] se realiza de forma secuencial (primero arr_len se lee, y luego arr).

¿Qué sucede cuando los 2 hilos se entrelazan? Puede ocurrir una de estas tres cosas:

• No hay problema - ¡Tienes suerte!
• arr_len es mayor que arr - UB :(
• arr se invalida (se borra) - UB :(