pthread_cond_t条件下的易失变量

Question

If I have a piece of code like this

pthread_cond_t c;
pthread_mutex_t m;
int var = 0;

void some_function(int *some_variable)
{
    pthread_mutex_lock(&m);
    while(*some_variable != 123)
        pthread_cond_wait(&c, &m);
    pthread_mutex_unlock(&m);
    // *some_variable++; (1)
}

void some_another_fun(int *some_variable)
{
    pthread_mutex_lock(&m);
    *some_variable = 123;
    pthread_cond_signal(&c);
    pthread_mutex_unlock(&m);
}

int main()
{
    // run 1 thread for some_function
    // and one for some_another_fun
    // pass `&var` to both of them
}

Should I declare some_variable or var as volatile in this case? Should I declare it as volatile if (1) is uncommented (ie *some_variable changes in some_function )?

Can a compiler cache *some_variable value in a register before executing while and never update it again?

I don't fully understand when I should use volatile keyword (even this answers has some contradiction and disagreements) thus this question.

Answer 1

The volatile is not needed because pthread functions contain a memory fence. See an answer to a similar question: Does pthread_mutex_lock contains memory fence instruction?

An important thing to note is that volatile does not mean that the access must be performed in any particular order compared to non-volatile accesses. This is why a memory fence is needed in inter-thread communication, instead of just having some global flags that we mark volatile(unless we mark everything in a program as volatile).