Multiple threads in C program

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

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;
}

Answer 5

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);