La concurrencia puede introducir problemas de sincronización cuando varios hilos acceden y modifican los mismos datos compartidos al mismo tiempo. Esto puede llevar a condiciones de carrera y resultados no deterministas.
Para manejar problemas de sincronización, C++ proporciona mecanismos como std::mutex (mutex) y std::lock_guard para lograr exclusión mutua y evitar condiciones de carrera. Estos mecanismos garantizan que solo un hilo pueda acceder a un recurso compartido en un momento dado.
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx; // Mutex para sincronización
void funcionHilo(int id) {
std::lock_guard<std::mutex> lock(mtx); // Bloquear el mutex
std::cout << "Hola desde el hilo " << id << std::endl;
}
int main() {
std::thread hilo1(funcionHilo, 1);
std::thread hilo2(funcionHilo, 2);
hilo1.join();
hilo2.join();
return 0;
}
Este es un ejemplo más elaborado de concurrencia utilizando hilos en C++. En este caso, se implementó una simulación simple de una carrera entre varios corredores utilizando hilos para representar a cada corredor. Utilizaremos mutex para garantizar que los resultados se impriman de manera ordenada y sincronizada.
#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
#include <chrono>
const int numCorredores = 5;
int posiciones[numCorredores];
std::mutex mtx;
void correr(int id) {
for (int i = 0; i < 10; ++i) {
// Simulamos la carrera con un retraso aleatorio
std::this_thread::sleep_for(std::chrono::milliseconds(rand() % 100));
// Actualizamos la posición del corredor
std::lock_guard<std::mutex> lock(mtx);
posiciones[id] = i + 1;
// Imprimimos la posición actualizada
std::cout << "Corredor " << id + 1 << ": Posición " << posiciones[id] << std::endl;
}
}
int main() {
std::vector<std::thread> corredores;
// Inicializamos las posiciones de los corredores
for (int i = 0; i < numCorredores; ++i) {
posiciones[i] = 0;
}
// Creamos los hilos para los corredores
for (int i = 0; i < numCorredores; ++i) {
corredores.emplace_back(correr, i);
}
// Esperamos a que todos los corredores terminen
for (auto& corredor : corredores) {
corredor.join();
}
// Imprimimos el resultado final
std::cout << "\nResultado Final:\n";
for (int i = 0; i < numCorredores; ++i) {
std::cout << "Corredor " << i + 1 << ": Posición " << posiciones[i] << std::endl;
}
return 0;
}
En este ejemplo, cada corredor (hilo) avanza en la carrera por un total de 10 pasos. Utilizamos un mutex para asegurarnos de que las actualizaciones de posición se realicen de manera sincronizada y evitemos condiciones de carrera. Al final de la carrera, imprimimos los resultados finales de cada corredor en orden.
Pueder ir al artículo principal:
Códigos Sencillos hechos en C++