What is the role of mutex in C++ multi-threaded programming?

In multi-threaded programming, using a mutex lock (mutex) can prevent multiple threads from accessing shared data at the same time, thereby avoiding data competition and inconsistency. The main functions include: 1. Protection of shared data; 2. Thread synchronization. In C++, mutex objects can be created and used through std::mutex. Shared data can only be accessed after acquiring the lock, and other threads can acquire the lock only after the lock is released.

The role of mutex in C++ multi-thread programming

In multi-thread programming, when multiple threads access shared data at the same time , may lead to data races and inconsistencies. To prevent this, a mutex can be used to ensure that shared data is only accessed by one thread at the same time.

What is mutex

Mutex is a synchronization primitive that allows threads to have mutually exclusive access to shared resources. After a thread acquires the mutex lock, other threads cannot acquire the lock until the thread releases the lock.

The role of mutex

In multi-threaded programming, mutex mainly has the following functions:

• Protect shared data:Prevent multiple threads from accessing shared data at the same time to ensure data integrity and consistency.
• Thread synchronization: Control the execution order of threads to ensure that certain operations are executed in a specific order.

How to use mutex

In C++, you can use std::mutex to create and use mutex objects:

// 创建一个 mutex 对象
std::mutex m;

// 获取 mutex 的锁
m.lock();

// 访问共享数据或执行操作

// 释放 mutex 的锁
m.unlock();

Practical case

The following is a practical case of using mutex to protect shared data:

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

std::mutex m;
int shared_data = 0;

void increment_shared_data() {
    m.lock();
    shared_data++;
    m.unlock();
}

int main() {
    std::thread t1(increment_shared_data);
    std::thread t2(increment_shared_data);

    t1.join();
    t2.join();

    std::cout << "Final value of shared_data: " << shared_data << std::endl;
    return 0;
}

In this case, two threads execute at the same time increment_shared_data() function to perform increment operation on shared_data. Since a mutex is used in the increment_shared_data() function to protect shared data, it is guaranteed that two threads will not access shared_data at the same time, thereby avoiding data competition.

The above is the detailed content of What is the role of mutex in C++ multi-threaded programming?. For more information, please follow other related articles on the PHP Chinese website!