Multiple threads in C program - c

Question

I'm writing a Unix application in C which uses multiple threads of control. I'm having a problem with the main function terminating before the thread it has spawned have a change to finish their work. How do I prevent this from happening. I suspect I need to use the pthread_join primitive, but I'm not sure how. Thanks!

Answer 1

Yes, you could use pthread_join() (see other anwers for how to do that). But let me explain the pthread model and show you another option.
In Unix, a process exits when the primary thread returns from main, when any thread calls exit() or when the last thread calls pthread_exit(). Based on the last option, you can simply have your main thread call pthread_exit() and the process will stay alive as long as at least one more thread is running.

Answer 2

Yes one of doing this is to use pthread_join function: that's assuming your thread is in "joinable" state.
pthread_create: after this function returns control, your thread will be executing your thread function.
after pthread_create, use the tid from pthread_create to pthread__join.
If your thread is detached, you must use some other technique e.g. shared variable, waiting on signal(s), shared queue etc.
Great reference material available here.

Answer 3

There are a number of different ways you can do this, but the simplest is to call pthread_exit() before returning from main().
Note that this technique works even if the thread you want to wait for is not joinable.

Answer 4

You may want to look at this page:
http://publib.boulder.ibm.com/iseries/v5r2/ic2924/index.htm?info/apis/users_25.htm
rc = pthread_create(&thread, NULL, threadfunc, NULL);
checkResults("pthread_create()\n", rc);
printf("Wait for the thread to exit\n");
rc = pthread_join(thread, &status);

Answer 5

Check this simple C code I wrote for one of my libraries
/*
* Copyright (c) 2011 Dino Ciuffetti <dino#tuxweb.it>, TuxWeb S.r.l., NuvolaBase Ltd
*
* This file is part of liborient.
*
* Liborient is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Liborient is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Liborient. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
//pthread_rwlock_t ptr_thr_lock = PTHREAD_RWLOCK_INITIALIZER;
typedef struct {
int t;
} thread_arguments;
void *thread_stuff(void *args) {
thread_arguments *t_args;
int tid;
t_args = (thread_arguments *)args;
//pthread_rwlock_rdlock(&ptr_thr_lock);
tid = t_args->t;
//pthread_rwlock_unlock(&ptr_thr_lock);
/*while (1) {
sleep (1);*/
printf("Thread #%i!\n", tid);
/*}*/
t_args = NULL;
pthread_exit(NULL);
return NULL;
}
int wait_threads(pthread_t threads[], thread_arguments *t_args[], int nthreads) {
int t;
int rc;
// Waiting for threads termination
for(t=0; t<nthreads; t++) {
rc = pthread_join(threads[t], NULL);
free(t_args[t]);
if (rc != 0) {
printf("Error waiting for termination of thread %i: %i\n", t, rc);
return 1;
break;
}
}
return 0;
}
int spawn_threads(pthread_t threads[], thread_arguments *t_args[], int nthreads) {
int t;
int rc;
// Spawning threads
for(t=0; t<nthreads; t++) {
t_args[t] = (thread_arguments *) malloc(sizeof(thread_arguments));
//pthread_rwlock_wrlock(&ptr_thr_lock);
t_args[t]->t = t;
//pthread_rwlock_unlock(&ptr_thr_lock);
printf("Spawning thread: %i\n", t);
rc = pthread_create(&threads[t], NULL, (void *)thread_stuff, (void *)t_args[t]);
if (rc != 0) {
printf("Error spawning thread %i: %i\n", t, rc);
wait_threads(threads, t_args, rc+1);
return t+1;
break;
}
}
return 0;
}
int main() {
pthread_t threads[20];
thread_arguments *t_args[20];
int rc;
rc = spawn_threads(threads, t_args, 20);
if (rc > 0) {
printf("Failed spawning thread number %i\n", rc-1);
return 1;
}
rc = wait_threads(threads, t_args, 20);
return 0;
}