What are some examples of thread-safe code in C++11?

What are some examples of thread-safe code in C++11?

Thread-safe code in C++11 ensures that shared data is accessed by multiple threads without causing data races. Examples include using mutexes, atomic operations, and condition variables.

Can you show me a simple example using mutexes?

Sure! Here's a simple example:

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

std::mutex mtx;
int shared_data = 0;

void increment() {
    mtx.lock();
    ++shared_data;
    mtx.unlock();
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Shared data: " << shared_data << std::endl;
}

This code safely increments shared_data using a mutex.

What are atomic operations, and how do they help?

Atomic operations are operations that complete in a single step relative to other threads. They help prevent data races without the overhead of locking, making them ideal for simple shared variables.

Can you explain condition variables and their use?

Condition variables are synchronization primitives that allow threads to wait until a particular condition occurs. They are used in conjunction with mutexes to manage complex thread interactions.