What are some examples of thread safety in C++?

What are some examples of thread safety in C++?

Thread safety in C++ refers to the practice of ensuring that shared data is accessed by multiple threads without causing data corruption. Here are a few examples:

1. Mutexes: Using std::mutex to protect shared resources.
2. Atomic Operations: Using std::atomic for operations that need to be thread-safe without locks.
3. Condition Variables: Using std::condition_variable to synchronize threads based on certain conditions.

Can you show me a code example using mutex?

Sure! Here's a simple example using std::mutex:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int sharedCounter = 0;

void incrementCounter() {
    mtx.lock();  // Lock the mutex
    ++sharedCounter;
    mtx.unlock();  // Unlock the mutex
}

int main() {
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);
    t1.join();
    t2.join();
    std::cout << "Final counter value: " << sharedCounter << std::endl;
    return 0;
}

What happens if I forget to unlock the mutex?

If you forget to unlock the mutex, it can lead to a deadlock situation where other threads trying to lock the same mutex will be blocked indefinitely. This can cause your program to hang and not function as expected.

Are there alternatives to using mutexes?

Yes, there are alternatives to using mutexes for thread safety in C++. Some of them include:

1. Read-Write Locks: Using std::shared_mutex for scenarios where multiple threads can read but only one can write.
2. Lock-Free Data Structures: Implementing data structures that do not require locks, using atomic operations.
3. Thread Local Storage: Using thread_local storage to give each thread its own instance of a variable.