c++ 互斥锁有哪些

C++中提供了多种互斥锁来实现线程同步和互斥访问，常用的有以下几种：

1. std::mutex：是C++11引入的基本互斥锁，使用最广泛的一种。可以使用lock()和unlock()函数来加锁和解锁。

2. std::recursive_mutex：是std::mutex的递归版本，允许同一个线程多次加锁而不会发生死锁。

3. std::timed_mutex：是std::mutex的可超时版本，允许在一定时间内尝试获取锁，如果超时则放弃。

4. std::recursive_timed_mutex：是std::timed_mutex的递归版本。

5. std::shared_mutex：是C++14引入的共享互斥锁，支持读写锁分离。多个线程可以同时获取读锁，但只有一个线程可以获取写锁。

这些互斥锁都定义在头文件<mutex>中，通过标准库提供的这些互斥锁，可以有效地保护共享资源避免多线程访问时的竞态条件。

相关问题

linux c++ 互斥锁

在Linux下使用C++进行互斥锁（Mutex）的操作，可以通过pthread库提供的函数来实现。下面是一个简单的示例代码，演示了如何在C++中使用互斥锁：

#include <iostream>
#include <pthread.h>

// 全局变量和互斥锁
int counter = 0;
pthread_mutex_t mutex;

// 线程函数
void* increment(void* arg) {
    for (int i = 0; i < 10000; ++i) {
        // 上锁
        pthread_mutex_lock(&mutex);

        // 临界区操作
        counter++;

        // 解锁
        pthread_mutex_unlock(&mutex);
    }
    return nullptr;
}

int main() {
    // 初始化互斥锁
    pthread_mutex_init(&mutex, nullptr);

    // 创建两个线程
    pthread_t thread1, thread2;
    pthread_create(&thread1, nullptr, increment, nullptr);
    pthread_create(&thread2, nullptr, increment, nullptr);

    // 等待线程结束
    pthread_join(thread1, nullptr);
    pthread_join(thread2, nullptr);

    // 销毁互斥锁
    pthread_mutex_destroy(&mutex);

    // 输出结果
    std::cout << "Counter: " << counter << std::endl;

    return 0;
}

在上述代码中，我们使用了互斥锁来保护共享变量`counter`的访问。两个线程通过互斥锁的上锁和解锁操作来确保在同一时刻只有一个线程可以访问共享变量。最后，我们输出了最终的计数器值。

注意，在编译时需要链接pthread库，可以使用以下命令进行编译：

g++ -pthread your_program.cpp -o your_program

希望这能解答你的问题！如果还有其他疑问，请随时追问。

c++ 互斥锁vector

在C++中，使用互斥锁来保护一个`std::vector`的访问可以确保线程安全。由于`std::vector`是一个可变大小的容器，多个线程同时对其进行读写操作可能导致竞争条件和数据损坏。

下面是一个使用互斥锁保护`std::vector`的示例：

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

std::vector<int> myVector;
std::mutex mtx;

void addToVector(int value) {
    std::lock_guard<std::mutex> lock(mtx);  // 锁定互斥锁
    myVector.push_back(value);
    // 在函数结束时自动释放互斥锁
}

int main() {
    std::thread t1(addToVector, 1);
    std::thread t2(addToVector, 2);

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

    // 输出向量的内容
    for (const auto& value : myVector) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    return 0;
}

在上面的示例中，`std::vector<int>`对象`myVector`是被多个线程访问的共享资源。通过在`addToVector`函数中使用`std::lock_guard<std::mutex>`来锁定互斥锁`mtx`，确保每个线程在访问和修改`myVector`之前先获得锁。这样可以避免多个线程同时修改`myVector`而导致数据不一致的问题。

使用互斥锁来保护`std::vector`的访问确保了线程安全性，但可能会带来性能开销。在某些情况下，如果读操作远远多于写操作，可以考虑使用读写锁(`std::shared_mutex`)来提高并发性能。读写锁允许多个线程同时读取共享资源，但在有线程进行写入时，其他线程无法进行读取或写入操作。