Creating a new thread each time a method is called using pthread

Question

I want to create a program that creates a new thread each time a specific method is called. Here is my working code so far:

#define NUMBER_OF_THREADS   3

pthread_t threads[NUMBER_OF_THREADS];
pthread_attr_t attr;

void *BusyWork(void *t)
{
   int i;
   long tid;
   tid = (long)t;

   printf("Thread %ld running...\n",tid);
    // ...
    printf("Thread %ld completed...\n",tid);

   pthread_exit((void*) t);
}

void createNewThread(int number){
    printf("running createNewThread(%d)\n", number);
    pthread_t tid;
    int rc = pthread_create( &tid, &attr, BusyWork, (void *) (long)number);
    if (rc) {
        printf("ERROR; return code from pthread_create() is %d\n", rc);
        exit(-1);
    }
}

int main(int argc, char *argv[]) {
    int i, rc;

    //Set up thread attributes
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

    //Arbitary amount of calls (My real program will call the createNewThread() funcion multiple unkown amount of times)
    createNewThread(15);
    createNewThread(27);
    createNewThread(62);
    createNewThread(500);
    createNewThread(8864);
    createNewThread(99999);

    //Free attributes
    pthread_attr_destroy(&attr);

    //Wait for other threads still running
    // HOW CAN I DO THIS????
    /*for (i=0; i< NUMBER_OF_THREADS; i++){
        rc = pthread_join( ??? , NULL); //TODO
        if (rc){
            printf("ERROR: return code from pthread_join() %d\n", rc);
            exit(-1);
        }
        printf("Main: completed join with thread %d\n", i);
    }*/

    printf("Main: program completed. Exiting.\n");


    pthread_exit(NULL); // (?) Is this part nessassary as we are on the main thread and soon to exit the program 

    return 0;
}

However as you can see in my code there is a few issues! For example, how can I wait for all processes to complete for the code I am using, as I am not keeping track of the thread number. Also when a thread "BusyWork" is done it does not clean up after it self and left as an orphan process.

One idea I had was to use a vector to keep track of each thread number and then use that for the final join at the end of main. However the problem with that is the array list can easily get very large and will never shrink even though a thread is complete.

Answer 1

Detach the threads, don't join them. Before you create a thread, increment a counter protected by a mutex. Right before a thread terminates, acquire the mutex and decrement the counter. Now you know all threads are done when the counter reads zero. You can use a condition variable to make the counter waitable if you like.