linux - How to understand condition variables in thread synchronization?

Question

The global variable is initialized to 0, two threads, one thread increments it by 1 each time, when it is greater than or equal to 100, sends a condition to the other thread. Reset to 0

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

But why do I print the following result under the reset thread? Shouldn't it be 100?
The reset thread has locked the mutex, but it seems that another thread is still accumulating.

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