C/C++ - sem_t 类型的单个信号量按顺序打印数字

Question

问题：假设我们有 n 个线程，每个线程接收一个介于 1 和 n 之间的随机唯一数。我们希望线程按排序顺序打印数字。

简单的解决方案（使用 n 个信号量/互斥量）：我们可以使用 n 个互斥锁（或类似的信号量），其中线程 i 等待获取互斥锁编号 i 并解锁编号 i + 1。此外，线程 1 没有等待。

但是，我想知道是否可以模拟类似的逻辑使用单个信号量（类型为 sem_t）来实现以下逻辑：（i 是介于 1 到 n 之间的数字）

编号为 i 的线程作为输入，等待获取信号量上的 (i-1) 个计数，然后 打印，释放 i 的计数。不用说，线程一没有 等等。

我知道与 Java 不同，sem_t 不支持信号量值的任意增加/减少。此外，由于异步，编写一个 for 循环来执行 (i-1) 等待和 i 释放将无法正常工作。

我一直在寻找答案，但找不到任何答案。这在普通的C语言中可能吗？如果不是，是否可以在 C++ 中仅使用一个变量或信号量？总的来说，使用 ONE 信号量做到这一点最浪费的方法是什么。

由于我是多线程编程的新手，请随时编辑问题。

Answer 1

您可以使用 C++ 中的 condition_variable 执行此操作，这相当于使用 C 中的 pthreads 库的pthread_cond_t。

您希望在线程之间共享的是指向条件变量、数字和互斥锁的指针，以保护对数字的访问。

struct GlobalData
{
    std::condition_variable cv;
    int currentValue;
    std::mutex mut;
};

每个线程简单地调用一个函数，等待其编号被设置：

void WaitForMyNumber(std::shared_ptr<GlobalData> gd, int number)
{
    std::unique_lock<std::mutex> lock(gd->mut);
    while (gd->currentValue != number)
    {
        gd->cv.wait(lock);
    }

    std::cout << number << std::endl;
    gd->currentValue++;
    gd->cv.notify_all(); // notify all other threads that it can wake up and check
}

然后是一个程序来测试它。这个使用 10 个线程。您可以修改它以使用更多，然后拥有自己的数字列表随机化算法。

int main()
{
    int numbers[10] = { 9, 1, 0, 7, 5, 3, 2, 8, 6, 4 };
    std::shared_ptr<GlobalData> gd = std::make_shared<GlobalData>();
    // gd->number is initialized to 0.

    std::thread threads[10];

    for (int i = 0; i < 10; i++)
    {
        int num = numbers[i];
        auto fn = [gd, num] {WaitForMyNumber(gd, num); };
        threads[i] = std::move(std::thread(fn));
    }

    // wait for all the threads to finish
    for (int i = 0; i < 10; i++)
    {
        threads[i].join();
    }

    return 0;
}

以上所有内容都是用 C++ 编写的。但是使用pthreads 将上述解决方案转换为C 很容易。但我会把它留给 OP 做练习。

我不确定这是否满足您的“一个信号量要求”。互斥体在技术上具有信号量。不确定 condition_variable 本身是否有用于实现的信号量。

Answer 2

这是一个很好的问题，但我担心您可能遇到 XY 问题，因为我无法想象您的问题场景的充分理由。尽管如此，在 1-2 分钟后，我想出了 2 个各有利弊的解决方案，但我认为一个对你来说是完美的：

A.当您的线程几乎同时完成并且/或者需要尽快打印时，您可以使用共享的std::atomic<T> 和T=unsigned,int,size_t,uint32_t，无论您喜欢什么，或者在使用 C 时使用 C 标准库中的任何整数原子，使用 C 初始化它0，现在我忙的每个线程都在等待，直到它的值为 i-1。如果是这样，它会打印然后在原子上添加 1。当然，由于繁忙的等待，当线程等待很长时间时，您将有很多 CPU 负载，而当许多线程等待时，您会减慢速度。但是你尽快得到你的印刷品

B.您只需将线程 i 的结果连同它的索引一起存储在一个容器中，因为我猜您想要更多只打印 i，并且在所有线程完成或定期完成后，对该容器进行排序，然后打印它。

答：

#include <iostream>
#include <atomic>
#include <thread>
#include <vector>
#include <functional>

void thread_function(unsigned i, std::atomic<unsigned>& atomic) {
    while (atomic < i - 1) {}
    std::cout << i << " ";
    atomic += 1;
}

int main() {
    std::atomic<unsigned> atomic = 0;

    std::vector<std::thread> threads;
    for (auto i : {3,1,2}) {
        threads.push_back(std::thread(thread_function, i, std::ref(atomic)));
    }
    for (auto& t : threads) {
        t.join();
    }
    std::cout << "\n";
}

也可以在 C 中使用，只需使用那里的原子。

Answer 3

以下代码使用 pthread_cond_t 并在 C 中工作。

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define n 100

int counter = 0;
int used[n];

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void foo(void *given_number){
    int number = (int)given_number;
    pthread_mutex_lock(&mutex);
    while(counter != number){
        pthread_cond_wait(&cond, &mutex);
    }
    printf("%d\n", number);
    counter++;
    pthread_cond_broadcast(&cond);
    pthread_mutex_unlock(&mutex);
}

int get_random_number(){
    while(1){
        int x = rand()%n;
        if(!used[x]){
            used[x] = 1;
            return x;
        }
    }
}

int main(){
    pthread_t threads[n];
    for(int i = 0; i < n; i++){
        int num = get_random_number();
        pthread_create(&threads[i], NULL, foo, (void *)num);    
    }
    for(int i = 0; i < n; i++){
        pthread_join(threads[i], NULL);
    }
    return 0;
}