Perché la lettura non è thread-safe?

Question

Mi chiedevo perché la lettura dalla memoria non è sicura per i thread. Tra ciò che ho visto finora, tra l'altro la domanda this, la lettura dalla memoria non sembra essere thread-safe.

Sono stato codificato in Python per un po 'e ora sto entrando in C++. Non ho mai sentito che leggere in Python non sia thread-safe.

Si prega di correggermi se ho torto, ma in caso contrario, per favore dimmi perché la lettura dalla memoria non è thread-safe.

Answer 1

La lettura è thread-safe, nessun problema ..... fino a quando qualcosa non scrive nella posizione da cui si sta leggendo, e poi ... beh, si spera che legga prima che i dati siano stati cambiati, o letti dopo il i dati sono stati modificati (in questi casi non ci sono preoccupazioni), ma a volte, proprio quando non lo vuoi davvero, leggerai a metà della scrittura e poi otterrai dati inutili.

Il modo per mitigare questo è quello di assicurarsi di leggere solo prima o dopo qualsiasi scrittura, il che richiede di controllare che si stia verificando una scrittura e utilizzare quindi un blocco di sincronizzazione di qualche tipo. Questo rende le cose più lente, dato che ovviamente stai controllando il blocco e poi leggendo invece di leggere. Se si sta lavorando con tipi di dati primitivi (ad esempio un int), è possibile utilizzare una sincronizzazione della CPU per accelerare notevolmente questa situazione.

Come per Python, è probabile che i dati python siano sempre sincronizzati per te dal runtime della lingua, se non lo è allora avrai gli stessi problemi di lettura del thread prima o poi. (Google veloce dice sì, Python will suffer the same problems non stai attento)

Answer 2

È thread-safe se molti thread stanno leggendo la stessa posizione, fino a quando nessuno tenta di scrivere lì.

Considerare se il thread A sta leggendo qualcosa nello stesso momento in cui il thread B sta scrivendo nella memoria da leggere. Genera un race condition. Il risultato della lettura può diventare non valido o diverso dal lancio al lancio

Answer 3

La lettura dalla memoria è thread-safe, tuttavia la lettura dalla memoria che può essere scritta nello stesso momento non è sicura.

In Python questo è meno problematico in quanto molti oggetti sono immutabili, quindi solo i riferimenti vengono modificati in questi casi, non la memoria stessa.

Answer 4

Leggere la stessa cosa contemporaneamente - è sicuro. Il problema è quando qualcosa vi scrive allo stesso tempo.

Si consideri il seguente codice:

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; 
} 

Supponiamo che arr[arr_len] è fatto in sequenza (prima arr_len viene letto, e poi arr).

Cosa succede quando i 2 thread vengono eseguiti con interfoliazione? Una delle tre cose può succedere:

• Nessun problema - Sei fortunato!
• arr_len è più grande di arr - UB :(
• arr viene invalidato (è stato cancellato) - UB :(