Multithreading 有没有其他同步方法

是否有其他方法确保线程已准备好接收广播信号。我想替换main中的Sleep（1）功能

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

#define NUM 4


using namespace std;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_t tid[NUM];


void *threads(void *arg){
    int tid = (int)arg;
    while(true){
        pthread_mutex_lock(&mutex);
        pthread_cond_wait(&cond,&mutex);
        //do some work
        cout<<"Thread: "<<tid<<endl;;
        pthread_mutex_unlock(&mutex);
    }
}

int main(){

    for(int i=0;i<NUM;i++){
        pthread_create(&tid[i],NULL,threads,(void*)i);
    }

    Sleep(1);
    pthread_cond_broadcast(&cond);

    Sleep(1);
    pthread_cond_broadcast(&cond);

    Sleep(1);
    pthread_cond_broadcast(&cond);

    return 0;
}

#包括
#包括
#定义数字4
使用名称空间std；
pthread\u mutex\u t mutex=pthread\u mutex\u初始值设定项；
pthread_cond_t cond=pthread_cond_初始值设定项；
pthread_t tid[NUM]；
void*线程（void*arg）{
int tid=（int）arg；
while（true）{
pthread_mutex_lock（&mutex）；
pthread_cond_wait（&cond，&mutex）；
//做些工作
cout条件变量通常连接到一个谓词。在其他线程中，检查谓词是否已经实现（在保持互斥保护谓词的同时进行检查），如果是，则不要等待条件变量。在main中，获取互斥体，在保持互斥体的同时更改谓词。然后释放互斥体并在condvar上发送信号或广播。下面是一个类似的问题：

下面是一些示例代码：

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

#include <cassert>

#define NUM 4
#define SIZE 256


using std::cout;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_t tid[NUM];

int work_available;

void *threads(void *arg)
{
    int tid = *((int*)arg);
    while (1) {
        pthread_mutex_lock(&mutex);
        while (work_available == 0) {
            // While loop since cond_wait can have spurious wakeups.                                                                                                                                                                                                                                                                                                                        
            pthread_cond_wait(&cond, &mutex);
            cout << "Worker " << tid << " woke up...\n";
            cout << "Work available: " << work_available << '\n';
        }
        if (work_available == -1) {
            cout << "Worker " << tid << " quitting\n";
            pthread_mutex_unlock(&mutex); // Easy to forget, better to use C++11 RAII mutexes.                                                                                                                                                                                                                                                                                              
            break;
        }
        assert(work_available > 0);
        work_available--;
        cout << "Worker " << tid << " took one item of work\n";
        pthread_mutex_unlock(&mutex);

        //do some work                                                                                                                                                                                                                                                                                                                                                                      
        sleep(2); // simulated work                                                                                                                                                                                                                                                                                                                                                         
        pthread_mutex_lock(&mutex);
        cout << "Worker " << tid << " done with one item of work.\n";
        pthread_mutex_unlock(&mutex);
    }
}


int main()
{
    work_available = 0;

    int args[NUM];
    for (int i=0; i<NUM; i++) {
        args[i] = i;
        pthread_create(&tid[i], NULL, threads, (void*)&args[i]);
    }

    const int MAX_TIME = 10;
    for (int i = 0; i < MAX_TIME; i++)
    {
        pthread_mutex_lock(&mutex);
        work_available++;
        cout << "Main thread, work available: " << work_available << '\n';
        pthread_mutex_unlock(&mutex);
        pthread_cond_broadcast(&cond);
        sleep(1);
    }

    pthread_mutex_lock(&mutex);
    cout << "Main signalling threads to quit\n";
    work_available = -1;
    pthread_mutex_unlock(&mutex);
    pthread_cond_broadcast(&cond);

    for (int i = 0; i < NUM; i++)
    {
        pthread_join(tid[i], NULL);

    }
    return 0;
}

#包括
#包括
#包括
#包括
#定义数字4
#定义大小256
使用std：：cout；
pthread\u mutex\u t mutex=pthread\u mutex\u初始值设定项；
pthread_cond_t cond=pthread_cond_初始值设定项；
pthread_t tid[NUM]；
int work_可用；
void*线程（void*arg）
{
int-tid=*（（int*）arg）；
而(1){
pthread_mutex_lock（&mutex）；
while（可用工时==0）{
//自cond_wait以来的While循环可能会出现虚假唤醒。                   
pthread_cond_wait（&cond，&mutex）；
cout条件变量通常连接到一个谓词。在其他线程中，检查谓词是否已经实现（在保持互斥保护谓词的同时进行检查），如果是，则不要等待条件变量。在main中，获取互斥体，在保持互斥体的同时更改谓词。然后释放互斥体并在condvar上发送信号或广播。下面是一个类似的问题：

下面是一些示例代码：

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

#include <cassert>

#define NUM 4
#define SIZE 256


using std::cout;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_t tid[NUM];

int work_available;

void *threads(void *arg)
{
    int tid = *((int*)arg);
    while (1) {
        pthread_mutex_lock(&mutex);
        while (work_available == 0) {
            // While loop since cond_wait can have spurious wakeups.                                                                                                                                                                                                                                                                                                                        
            pthread_cond_wait(&cond, &mutex);
            cout << "Worker " << tid << " woke up...\n";
            cout << "Work available: " << work_available << '\n';
        }
        if (work_available == -1) {
            cout << "Worker " << tid << " quitting\n";
            pthread_mutex_unlock(&mutex); // Easy to forget, better to use C++11 RAII mutexes.                                                                                                                                                                                                                                                                                              
            break;
        }
        assert(work_available > 0);
        work_available--;
        cout << "Worker " << tid << " took one item of work\n";
        pthread_mutex_unlock(&mutex);

        //do some work                                                                                                                                                                                                                                                                                                                                                                      
        sleep(2); // simulated work                                                                                                                                                                                                                                                                                                                                                         
        pthread_mutex_lock(&mutex);
        cout << "Worker " << tid << " done with one item of work.\n";
        pthread_mutex_unlock(&mutex);
    }
}


int main()
{
    work_available = 0;

    int args[NUM];
    for (int i=0; i<NUM; i++) {
        args[i] = i;
        pthread_create(&tid[i], NULL, threads, (void*)&args[i]);
    }

    const int MAX_TIME = 10;
    for (int i = 0; i < MAX_TIME; i++)
    {
        pthread_mutex_lock(&mutex);
        work_available++;
        cout << "Main thread, work available: " << work_available << '\n';
        pthread_mutex_unlock(&mutex);
        pthread_cond_broadcast(&cond);
        sleep(1);
    }

    pthread_mutex_lock(&mutex);
    cout << "Main signalling threads to quit\n";
    work_available = -1;
    pthread_mutex_unlock(&mutex);
    pthread_cond_broadcast(&cond);

    for (int i = 0; i < NUM; i++)
    {
        pthread_join(tid[i], NULL);

    }
    return 0;
}

#包括
#包括
#包括
#包括
#定义数字4
#定义大小256
使用std：：cout；
pthread\u mutex\u t mutex=pthread\u mutex\u初始值设定项；
pthread_cond_t cond=pthread_cond_初始值设定项；
pthread_t tid[NUM]；
int work_可用；
void*线程（void*arg）
{
int-tid=*（（int*）arg）；
而(1){
pthread_mutex_lock（&mutex）；
while（可用工时==0）{
//自cond_wait以来的While循环可能会出现虚假唤醒。                   
pthread_cond_wait（&cond，&mutex）；
难道我遗漏了什么？我在第一行添加了更改后的代码posting@TomNeumeier只有当谓词为false时，工作线程才应该进入睡眠状态。您不需要多次切换谓词，只有在线程可以继续执行condvar wait之后，才将其设置为true。@TomNeumeier当然可以，这取决于您想要做什么可以。我在回答中添加了一个示例，您可以根据自己的需要对其进行调整。您的示例可以从主线程调用线程一次。我希望能够从主线程多次向线程发送信号。@TomNeumeier是的，我理解。您可以使用“工作计数器”，在主线程中递增，在工作线程中递减，然后签名介于两者之间。或者使用sempahore，但它们与condvar的集成不如互斥体。我缺少什么？我在第一个部分添加了更改后的代码posting@TomNeumeier仅当谓词为false时，工作线程才应进入睡眠状态。您不需要多次切换谓词，只需在线程为ok时将其设置为true在condvar wait之后继续。@TomNeumeier当然可以，这取决于您想做什么。我在回答中添加了一个示例，您可以根据自己的需要调整它。您的示例可以从主线程调用线程一次。我希望能够从主线程多次向线程发送信号。@TomNeumeier是的，我理解d、 您可以使用“工作计数器”，在主线程中递增，在工作线程中递减，在两者之间发送信号。或者使用sempahore，但它们与condvar的集成不如互斥体好。