How do I resolve 'data race' detected by TSan in C++?

Data races in C++ occur when multiple threads access the same memory location simultaneously, and at least one of the accesses is a write. Thread Sanitizer (TSan) helps detect these data races, allowing developers to resolve them before they lead to undefined behavior or bugs. Here are some strategies to resolve data races in your C++ applications:

• Mutexes: Use mutexes to protect shared resources. A mutex locks the resource for one thread while preventing others from accessing it.
• Atomic Operations: Use atomic types (e.g., std::atomic) when incrementing or accessing shared variables to ensure thread-safe operations.
• Thread Synchronization: Ensure threads complete their tasks in a specific order using synchronization primitives like condition variables, semaphores, or barriers.
• Thread-local Storage: Use thread-local storage to avoid sharing data between threads. Each thread gets its own instance of the variable, preventing conflicts.

Here’s an example to illustrate the implementation of mutexes to resolve data races:

// Example of serializing access to shared data using mutex
#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;  // Mutex for protecting shared resource
int shared_data = 0;

void increment() {
    for (int i = 0; i < 1000; ++i) {
        mtx.lock();       // Lock the mutex
        ++shared_data;    // Increment the shared resource
        mtx.unlock();     // Unlock the mutex
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    
    t1.join();
    t2.join();

    std::cout << "Final value of shared_data: " << shared_data << std::endl; // Output should be 2000
    return 0;
}