pthreads / C：使用标志优雅地终止其他线程

Question

Is it safe (and a good practice) to use a flag which is written by only one thread and only read by other threads to gracefully terminate threads?

Consider the following code:

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

static int run;
static pthread_t t1, t2;

static void *threadFunc(void *context)
{
    puts("thread starting");

    init();

    while(run)
    {
        do_stuff();
    }

    clean_up();

    puts("thread exiting");

    return NULL;
}

int main(int argc, char **argv)
{
    puts("program starting");
    run = 1;

    pthread_create(&t1, NULL, threadFunc, NULL);
    pthread_create(&t2, NULL, threadFunc, NULL);

    do_some_stuff();

    run = 0;

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    puts("program exiting");
    return 0;
}

The variable "run" is used to tell threads t1 and t2 to terminate. Is that fine or I should use a mutex / memory barriers? And why? I don't care if it takes a couple more loop cycles before the threads exit, but I don't want them to run forever. I don't want to use pthread_cancel() as I want the threads to quit only after they complete a cycle of their main loop.

thanks

Answer 1

The safest approach is to make run atomic. Modern C does support atomic types.

Answer 2

You need a mutex to protect the shared variable because that's what the pthreads standard says. You can't assume that the worst way it will fail is taking "a couple more loop cycles before the threads exit".

It can crash. It can fail to ever stop. Anything can happen.

If your platform supports some kind of atomic type or atomic operations, you can use that.

Some people think using volatile is acceptable only for a "shutdown" flag. Be aware that this is very platform-specific and may or may not work for you. I don't consider it acceptable on platforms that have better options, that is, on all modern platforms.