C++
Tipos atómicos
Buscar..
Sintaxis
- std :: atómico <T>
- std :: atomic_flag
Observaciones
std::atomic
permite el acceso atómico a un tipo TriviallyCopyable, es dependiente de la implementación si esto se realiza mediante operaciones atómicas o mediante el uso de bloqueos. El único tipo atómico sin bloqueo garantizado es std::atomic_flag
.
Acceso multihilo
Se puede usar un tipo atómico para leer y escribir de forma segura en una ubicación de memoria compartida entre dos subprocesos.
Un mal ejemplo que puede causar una carrera de datos:
#include <thread>
#include <iostream>
//function will add all values including and between 'a' and 'b' to 'result'
void add(int a, int b, int * result) {
for (int i = a; i <= b; i++) {
*result += i;
}
}
int main() {
//a primitive data type has no thread safety
int shared = 0;
//create a thread that may run parallel to the 'main' thread
//the thread will run the function 'add' defined above with paramters a = 1, b = 100, result = &shared
//analogous to 'add(1,100, &shared);'
std::thread addingThread(add, 1, 100, &shared);
//attempt to print the value of 'shared' to console
//main will keep repeating this until the addingThread becomes joinable
while (!addingThread.joinable()) {
//this may cause undefined behavior or print a corrupted value
//if the addingThread tries to write to 'shared' while the main thread is reading it
std::cout << shared << std::endl;
}
//rejoin the thread at the end of execution for cleaning purposes
addingThread.join();
return 0;
}
El ejemplo anterior puede causar una lectura dañada y puede llevar a un comportamiento indefinido.
Un ejemplo con seguridad de hilo:
#include <atomic>
#include <thread>
#include <iostream>
//function will add all values including and between 'a' and 'b' to 'result'
void add(int a, int b, std::atomic<int> * result) {
for (int i = a; i <= b; i++) {
//atomically add 'i' to result
result->fetch_add(i);
}
}
int main() {
//atomic template used to store non-atomic objects
std::atomic<int> shared = 0;
//create a thread that may run parallel to the 'main' thread
//the thread will run the function 'add' defined above with paramters a = 1, b = 100, result = &shared
//analogous to 'add(1,100, &shared);'
std::thread addingThread(add, 1, 10000, &shared);
//print the value of 'shared' to console
//main will keep repeating this until the addingThread becomes joinable
while (!addingThread.joinable()) {
//safe way to read the value of shared atomically for thread safe read
std::cout << shared.load() << std::endl;
}
//rejoin the thread at the end of execution for cleaning purposes
addingThread.join();
return 0;
}
El ejemplo anterior es seguro porque todas las operaciones de store()
y load()
del tipo de datos atomic
protegen el int
encapsulado del acceso simultáneo.
Modified text is an extract of the original Stack Overflow Documentation
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow