linux - Wie versteht man Bedingungsvariablen bei der Thread-Synchronisierung?

Question

Die globale Variable wird auf 0 initialisiert. Zwei Threads, ein Thread erhöht sie jedes Mal um 1. Wenn sie größer oder gleich 100 ist, wird eine Bedingung an den anderen Thread gesendet

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


struct foo{
    int f_count;
    pthread_mutex_t f_lock;
    pthread_cond_t f_cond;
};

/* 初始化互斥量与条件变量 */
struct foo * foo_alloc(){
    struct foo *fp;
    if((fp = malloc(sizeof(struct foo))) != NULL){
        fp->f_count = 0;
        pthread_mutex_init(&fp->f_lock, NULL);
        pthread_cond_init(&fp->f_cond, NULL);
    }
    return fp;
}

/* 加法 */
void *foo_increase(void *arg){
    
    struct foo *fp;

    fp = (struct foo*)arg;

    while(1){
        pthread_mutex_lock(&fp->f_lock);
    
        fp->f_count++;
        /* 大于等于100时发送条件 */
        if(fp->f_count >= 100){
            pthread_cond_signal(&fp->f_cond);
        }

        pthread_mutex_unlock(&fp->f_lock);
    }
}

/* 重新置０ */
void *foo_print(void *arg){
    struct foo *fp;
    fp = (struct foo*)arg;

    while(1){
        pthread_mutex_lock(&fp->f_lock);
        
        while(fp->f_count < 100){
            //释放掉锁, 等待条件为真返回, 再次锁住.
            pthread_cond_wait(&fp->f_cond, &fp->f_lock);
        }
        printf("重置 : %d\n", fp->f_count);    
        /* 重新置0 */    
        fp->f_count = 0;
        pthread_mutex_unlock(&fp->f_lock);
    }
}


int main(void){

    struct foo *fp;
    pthread_t tid_increase1, tid_print;
    //初始化
    fp = foo_alloc();

    //加法线程
    pthread_create(&tid_increase1, NULL, foo_increase, fp);
    
    //重置线程
    pthread_create(&tid_print, NULL, foo_print, fp);

    //防止主线程提前退出
    sleep(20);
    exit(0);
}

Aber warum wird das folgende Ergebnis gedruckt, wenn ich es unter dem Reset-Thread ausdrucke? Sollte es nicht 100 sein?

Der Reset-Thread hat den Mutex gesperrt, aber es scheint, dass sich noch ein weiterer Thread ansammelt.

置０前 : 54
置０前 : 92
置０前 : 47
置０前 : 85
置０前 : 51
．．．

Answer 1

#include <stdio.h>

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

struct foo{
    int f_count;
    pthread_mutex_t f_lock;
    pthread_cond_t f_cond;
};

/* 初始化互斥量与条件变量 */
struct foo * foo_alloc(){
    struct foo *fp;
    if((fp = (struct foo *)malloc(sizeof(struct foo))) != NULL){
        fp->f_count = 0;
        pthread_mutex_init(&fp->f_lock, NULL);
        pthread_cond_init(&fp->f_cond, NULL);
    }
    return fp;
}

/* 加法 */
void *foo_increase(void *arg){
    
    struct foo *fp;

    fp = (struct foo*)arg;

    while(1){
        
        pthread_mutex_lock(&fp->f_lock);
        
        fp->f_count++;
        
        if(fp->f_count >= 100){
            pthread_cond_signal(&fp->f_cond);
            
            //-------------------这里要等待，不然会再次循环+1
            pthread_cond_wait(&fp->f_cond, &fp->f_lock);
        }
        

        pthread_mutex_unlock(&fp->f_lock);
        
         /* 大于等于100时发送条件 */

    }
}

/* 重新置０ */
void *foo_print(void *arg){
    struct foo *fp;
    fp = (struct foo*)arg;

    while(1){
        pthread_mutex_lock(&fp->f_lock);
        
        while(fp->f_count < 100){
            
            //释放掉锁, 等待条件为真返回, 再次锁住.
            pthread_cond_wait(&fp->f_cond, &fp->f_lock);

        }
        printf("重置 : %d\n", fp->f_count);    
        /* 重新置0 */    
        fp->f_count = 0;
        
        //-------------------加这条就不会阻塞了foo_increase里的wait
        pthread_cond_signal(&fp->f_cond);
        
        pthread_mutex_unlock(&fp->f_lock);
    }
}


int main(void){

    struct foo *fp;
    pthread_t tid_increase1, tid_print;
    //初始化
    fp = foo_alloc();

    //加法线程
    pthread_create(&tid_increase1, NULL, foo_increase, fp);
    
    //重置线程
    pthread_create(&tid_print, NULL, foo_print, fp);

    //防止主线程提前退出
    sleep(2);这里这时要

    free(fp);//DO NOT FORGET

    exit(0);