c++ 信号量 互斥锁

C++中的信号量和互斥锁都是用来保护共享资源的线程同步机制。

互斥锁是一种最基本的线程同步机制，它通过互斥访问来保护共享资源。当一个线程获得了互斥锁，其他线程便无法获得该锁，只能等待该线程释放锁后再进行访问。C++中使用`std::mutex`来实现互斥锁。

信号量是一种更为复杂的线程同步机制，它可以用来控制多个线程对共享资源的访问。C++中使用`std::semaphore`来实现信号量。

在使用互斥锁和信号量时，需要特别注意防止死锁的发生。死锁是指两个或多个线程相互等待对方释放资源，从而导致程序无法继续执行的情况。

相关问题

我的具体需求是A线程执行read时，B线程阻塞，A线程执行完read后，B线程恢复，那么我该使用读写锁、信号量sem、互斥锁mutex还是信号cond，请告诉我在C/C++怎么办

要实现你描述的需求，即A线程读取数据时，B线程等待，A线程完成后再唤醒B线程，可以使用互斥锁(mutex)或者条件变量(cond)。互斥锁用于控制对共享资源的访问权限，而条件变量则允许线程在满足特定条件时被唤醒。

在C++中，你可以这样做：

1. 使用互斥锁Mutex[^1]:

#include <mutex>
#include <thread>

std::mutex mtx;
bool dataReady = false; // 标记数据是否准备好

void readerThread() {
    std::lock_guard<std::mutex> lock(mtx);
    // A线程读取数据...
    dataReady = true; // 设置数据已准备
    lock.unlock();
}

void writerThread() {
    while (!dataReady) {
        std::unique_lock<std::mutex> lock(mtx);
        // B线程等待直到数据准备好
        std::this_thread::yield(); // 或者调用其他同步原语
        lock.unlock();
    }
    // B线程开始执行...
}

2. 使用条件变量Cond:

#include <condition_variable>
#include <thread>

std::condition_variable cv;
bool dataReady;

void readerThread() {
    // A线程读取数据...
    dataReady = true;
    cv.notify_one(); // 唤醒等待的writerThread
}

void writerThread() {
    std::unique_lock<std::mutex> lock(cv_mutex);
    cv.wait(lock, []{ return dataReady; }); // 等待直到数据准备好
    // B线程开始执行...
}

在这两个方案中，`readerThread()`完成后会设置标志或通知其他线程，`writerThread()`会根据标志或条件变量的改变来决定何时继续执行。

建立一个控制台程序，建立四个线程，每个线程的功能为：输出0-9 共计10个数字，要求线程的输出为连续输出，借助信号量或者互斥锁进行实现。

好的，我来回答你的问题。

以下是一个简单的 C++ 控制台程序，它创建了四个线程并使用互斥锁控制它们的输出。每个线程输出数字0到9，共计10个数字。

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

std::mutex mtx;
int count = 0;

void printNumber(int id) {
    for (int i = 0; i < 10; ++i) {
        mtx.lock();
        std::cout << "Thread " << id << " Output: " << count << std::endl;
        ++count;
        mtx.unlock();
    }
}

int main() {
    std::thread t1(printNumber, 1);
    std::thread t2(printNumber, 2);
    std::thread t3(printNumber, 3);
    std::thread t4(printNumber, 4);

    t1.join();
    t2.join();
    t3.join();
    t4.join();

    return 0;
}

在这个程序中，我们使用了一个互斥锁（`std::mutex`）来确保每个线程的输出是连续的。每个线程输出前会先锁住互斥锁，输出后再释放锁。

注意到在这个程序中，我们使用了一个全局变量 `count` 来记录当前输出的数字。由于多个线程会同时访问这个变量，我们需要使用互斥锁来防止竞争条件的发生。

最后，我们创建了四个线程并启动它们，等待它们全部结束后程序才会退出。

希望这个程序能够帮助你理解如何使用互斥锁来控制多个线程的输出。