What are the types and uses of locks in C++ multi-threaded programming?

C++ The types of locks in multi-threaded programming include: Mutex locks: ensure that only one thread is allowed to access shared resources at a time. Read-write locks: allow multiple threads to read shared resources at the same time, but only one thread can write to themselves at a time. Spin lock: constantly check the status of the lock to avoid waiting for the lock. Available condition variables: used to wait for a certain condition to be met

Types of locks in C++ multi-thread programming And purpose

Lock is an important tool in multi-threaded programming for coordinating thread access to shared resources. In C++, there are several types of locks, each with its own unique purpose.

1. Mutex lock (Mutex)

Mutex lock is the most basic lock type, which only allows one thread to access the critical section (shared resource) at a time.

// 创建一个互斥锁
std::mutex mtx;

// 获取互斥锁（线程等待直到锁可用）
mtx.lock();

// 使用临界区
// ...

// 释放互斥锁（允许其他线程获取锁）
mtx.unlock();

2. Read-write lock (RWLock)

Read-write lock allows multiple threads to read shared resources at the same time, but only one thread can write at a time.

// 创建一个读写锁
std::shared_timed_mutex rwmtx;

// 获取读锁（线程可以在其他线程读取时读取）
rwmtx.lock_shared();

// 获取写锁（线程必须独占访问共享资源）
rwmtx.lock();

// 读取或写入临界区
// ...

// 释放锁
rwmtx.unlock();
rwmtx.unlock_shared();

3. Spinlock(Spinlock)

A spin lock is similar to a mutex lock, but when the lock is unavailable, the spin lock will continuously check the lock. status instead of waiting.

// 创建一个自旋锁
std::atomic_flag spinlock = ATOMIC_FLAG_INIT;

// 获取自旋锁
while (spinlock.test_and_set(std::memory_order_acquire));

// 使用临界区
// ...

// 释放自旋锁
spinlock.clear(std::memory_order_release);

4. Condition variable (Condition Variable)

Condition variable is used to wait for a certain condition to be met. It is used in conjunction with a mutex lock to allow a thread to wait when a condition is not met, and wakes the thread to continue execution.

// 创建一个条件变量
std::condition_variable cv;

// 获取互斥锁
std::mutex mtx;
mtx.lock();

// 等待条件满足
cv.wait(mtx);

// 执行被唤醒后的操作
// ...

// 释放互斥锁
mtx.unlock();

Practical case

Consider an application that contains a thread-safe queue. The queue structure contains a mutex that protects queue operations.

class Queue {
    private:
        std::queue<int> queue;
        std::mutex mtx;
    public:
        void push(int value) {
            std::lock_guard<std::mutex> lock(mtx);
            queue.push(value);
        }

        int pop() {
            std::lock_guard<std::mutex> lock(mtx);
            int value = queue.front();
            queue.pop();
            return value;
        }
};

In a multi-threaded environment, a mutex ensures that only one thread accesses the queue at the same time, thereby preventing data races and queue corruption.

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