使用pthread_create调用类型为“ int argc，char ** argv-> int”的C函数。

Question

I need to use pthread_create to invoke a C function of type

int main_original(int argc, char** argv)

I have tried something like this:

pthread_create(&t, NULL, main_original, NULL);

The compiler gives me a type error

invalid conversion from 'int (*)(int, char**)' to 'void* ( )(void )'

So, what is the right way to invoke main_original so that its parameters are well passed?

Answer 1

The function pthread_create is only able to call functions with the following signature:

void *fn(void *)

Even if you did manage to cast a pointer to a function with a different signature and successfully pass it to pthread_create , your program is likely to crash as pthread_create will attempt to set up the stack / registers in a way that follows the platform's calling convention for a function with just one void * argument, which will lead to your function being in an indeterminate state.

The way to solve your problem would be to use a wrapper function specifically designed for being called by pthread_create like so:

void *main_original_start_routine(void *arg)
{
    main_original(argc, argv);
    return NULL;
}

However, this may not be enough, unless argc and argv are global variables. You may find you also need to somehow pass these values through to this function from the scope in which you call pthread_create . This can be done via the void *arg argument to pthread_create , by creating a struct holding the state you need, and passing it around via a casted void pointer:

struct main_original_context {
    int argc;
    char **argv;
};

void *main_original_start_routine(void *arg)
{
    /* Convert the void pointer back to the struct pointer it
     * really is. */
    struct main_original_context *ctx = arg;
    main_original(ctx->argc, ctx->argv);
    return NULL;
}

int main(int argc, char **argv)
{
    pthread_t t;

    struct main_original_context ctx = {
        argc,
        argv
    };

    /* Pass a pointer to our context struct to the thread routine. */
    pthread_create(&t, NULL, &main_original_start_routine, &ctx);

    pthread_join(&t, NULL);

    return 0;
}

Keep in mind however, that ctx only has a lifetime of the duration of the main function in this case. If the function we create the pthread in does not join with pthread_join before returning (and invalidating the struct used to provide context to the thread), then this would be unsafe. Therefore we would have to use dynamic allocation, and make the thread assume responsibility for freeing any dynamically allocated memory:

struct main_original_context {
    int foo;
    int bar;
};

void *foobar_start_routine(void *arg)
{
    struct main_original_context *ctx = arg;
    foobar(ctx->foo, ctx->bar);

    /* Free memory we have been given responsibility for. */
    free(ctx);

    return NULL;
}

void asdf(int foo, int bar)
{
    pthread_t t;

    struct main_original_context *ctx;

    /* Allocate memory. */
    ctx = malloc(sizeof *ctx);

    ctx->foo = foo;
    ctx->bar = bar;

    /* Assume `main_original_start_routine` is now responsible for freeing
     * `ctx`. */
    pthread_create(&t, NULL, &foobar_start_routine, ctx);

    /* Now we can safely leave this scope without `ctx` being lost.  In
     * the real world, `t` should still be joined somewhere, or
     * explicitly created as a "detached" thread. */
}