在C中将“线程入口点”函数称为“常规”函数，这是不好的代码习惯吗？

Question

I recently faced a very particular situation in which I had to think about using the same function both in a "normal" function call and as a "thread entry point" function, using POSIX threads, in C.

Let me better explain the situation: I have a program which, depending on the user choices, should perform different tasks.

Two tasks are quite similar but they differ in the sense that, in one case, one set of operations should be performed in parallel to another one, and in the second case, instead, almost the same set of operations should be necessarily performed before the other one, eliminating the need to create a dedicated thread.

Since the "common" set of operations is very similar in the two cases, I actually wrote a code like the following:

if(task_type==0) {
    // Create two threads
    pthread_create(&tid[0],NULL,&common_operations,(void *) &args);
    pthread_create(&tid[1],NULL,&parallel_operations,(void *) &args);

    pthread_join(tid[0],NULL);
    pthread_join(tid[1],NULL);
} else if(task_type==1) {
    common_operations(&args); // Thread entry point function called as "normal function"
    sequential_operations(&args); // Different with respect to "parallel_operations"
}

Defining the "common_operations" function as:

static void *common_operations (void *arg) {
    // Properly casting void *arg to the right struct, containing, among the other things, "task_type"      

    // Function body....

    if(arg->task_type==0) {
        pthread_exit(NULL);
    } else {
        return NULL;
    }
}

I've never seen a thread entry point function used in this way and I was wondering whether this can be considered acceptable or if it is a bad code pratice to mix things in this way.

Moreover, are there better solutions for this specific case?

Answer 1

It's certainly valid to call a "thread function" like any other function. There's nothing wrong as such as long as, you convert (cast) to the correct type, it should be fine. Whether it's a good practice is subjective. This is a so uncommon that it'd be hard to find anyone calling it outright "a bad practice, you must avoid" :)

However, you can rewrite slightly so that the "normal" function vs. thread function distinction is clear. And make it a void function so that it doesn't return anything in the single-threaded call, which would otherwise look a tad odd. This would also avoid potential spaghetti code.

/* Use it in direct, single-threaded call */
static void common_operations(common_arg_type *arg) {
    // Function body....
}

/* Use it in pthread_create call */
static void *common_operations_thread(void *arg) {
    common_operations(args);
    return NULL; /* equivalent to pthread_exit(NULL); */
}

IMO, the considerations you should give are just same for any multi-threaded program: the function remains thread-safe and any function you call from the thread-function are also thread-safe and so on. Otherwise, there's not anything to be concerned about.