pthread Возвращаемые значения в массив

Question

В настоящее время я работаю над проектом, использующим pthreads. До сих пор проект запускает указанное пользователем количество потоков и затем выполняет некоторую работу над каждым потоком. Каждый поток хранится в динамически распределенном массиве памяти. Я делаю это с помощью:

threads = malloc(number_of_threads * sizeof(pthread_t));

Затем я создаю каждую нить для цикла:

pthread_create(&(threads[i]), NULL, client_pipe_run, (void *) &param[i]); 

Что мне нужно делать дальше сохранять возвращаемые значения этих потоков. Я понимаю, что мне нужно передать pthread_join адрес указателя, в котором я хочу получить возвращаемое значение. Здесь я немного запутался. Я в порядке с указателями до этого момента, тогда мой мозг имеет плавную ха-ха. Это моя идея о том, как добиться этого, но я не уверен, что это правильно:

int *return_vals = malloc(sizeof(int) * number_of_threads); 
for(i = 0; i< number_of_threads; i++) 
{ 
pthread_join(&(threads[i]),(void *) &(return_vals[i])); 
} 

Затем, чтобы получить возвращаемое значение, я бы сделать что-то похожее на:

int val = *(return_val[0]); 

Любая помощь на это было бы очень признательно!

Answer 1

Обратите внимание, что вы выделение памяти для потоков, как это:

threads = malloc(number_of_thread * sizeof(pthread_t)); 

но для возвращения значения вы:

int *return_vals = malloc(sizeof(int *)); 

т.е. число потоков должно быть принято в счете здесь:

int *return_vals = malloc(number_of_thread * sizeof(int)); 

Затем вы можете либо вернуть возвращаемое значение в void*:

void *foo(void *arg) { 
    int i = 7; 
    return (void*)i; 
} 

int main(void) { 
    int i = 0; 
    int thread_count = 3; 
    pthread_t* threads = malloc(thread_count * sizeof(pthread_t)); 
    int *return_vals = malloc(thread_count * sizeof(int)); 

    // create threads: 
    for(i = 0; i < thread_count; ++i) 
     pthread_create(&threads[i], NULL, &foo, NULL); 

    // wait untill they finish their work: 
    for(i = 0; i < thread_count; ++i) 
     pthread_join(threads[i], (void**) &return_vals[i]); 

    // print results: 
    for(i = 0; i < thread_count; ++i) 
     printf("Thread %d returned: %d\n", i, return_vals[i]); 

    // clean up: 
    free(return_vals); 
    free(threads); 

    return 0; 
} 

или вы можете убедиться, что ваш код не делает никаких предположений о размере типа вы возвращающийся быть меньше или равно sizeof(void*) и выделением памяти для возвращаемого значения динамически в потоке :

void *foo(void *arg) { 
    int* ret = malloc(sizeof(int)); 
    *ret = 7; 
    return ret; 
} 

int main(void) { 
    int i = 0; 
    int thread_count = 3; 
    pthread_t* threads = malloc(thread_count * sizeof(pthread_t)); 

    // array of pointers to return values of type int: 
    int **return_vals = calloc(thread_count, sizeof(int*)); 

    // create threads: 
    for(i = 0; i < thread_count; ++i) 
     pthread_create(&threads[i], NULL, &foo, NULL); 

    // wait untill they finish their work: 
    for(i = 0; i < thread_count; ++i) 
     pthread_join(threads[i], (void**) &return_vals[i]); 

    // print results: 
    for(i = 0; i < thread_count; ++i) 
     printf("Thread %d returned: %d\n", i, *return_vals[i]); 

    // clean up: 
    for(i = 0; i < thread_count; ++i) 
     free(return_vals[i]); 
    free(return_vals); 
    free(threads); 

    return 0; 
} 

Но если вы выбрали последний, будьте осторожны с возможными утечками памяти, которые могут возникнуть.