linux - Comment comprendre les variables de condition dans la synchronisation des threads?

Question

La variable globale est initialisée à 0. Deux threads, un thread l'incrémente de 1 à chaque fois Lorsqu'elle est supérieure ou égale à 100, envoyez une condition à l'autre thread.

#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);
}

Mais pourquoi le résultat suivant est-il imprimé lorsque je l'imprime sous le fil de réinitialisation ? Ne devrait-il pas être 100 ?

Le fil de réinitialisation a verrouillé le mutex, mais il semble qu'un autre fil s'accumule encore.

置０前 : 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);