Joining thread before creating it

[John Erlandsson]

Hi!

I am new to the forum, and kind of new to c programming.

Came a cross a problem while writing my first multithreaded program:

while( cyclic task )
{
    some stuff...

    if( condition )
    {
        pthread_mutex_lock( g_thread_finished_mutex );
        if(  g_thread_finished )
        {
            pthread_join( thread_ID, NULL );
            pthread_create( &thread_ID, NULL, thread_func, NULL );
        }
        pthread_mutex_unlock( g_thread_finished_mutex );
    }
    
    some other stuff...
}

thread_func is slow... It takes about 1s to finish and i only want one running at a time...

g_thread_finished is an int that is initiated to 1. Then set to 0 in the beginning of thread_func, and back to 1 at the end.

This throws a segmentation fault. But if i move the join call below the create call, everything works fine (Except that it looses all purpose).

What is the problem? Shouldn't the pthread_join function simply return a NULL value the first time?

Any ideas on how to solve this?

Also. Do I need to lock the thread_finished mutex when reading the variable, or is it only necessary when writing?

Any help is appreciated.

//John

[anduril462]

Without the rest of your code, I can't tell, but I would guess that, the first time through, thread_ID is uninitialized, and thus you are trying to join a non-existent thread. Something akin to closing an unopened, uninitialized file pointer. But with just what you posted, I can't say for sure. You have to create a thread before you can join it.

[CommonTater]

Could you join Facebook before they created it?
Think about it....

There ya go.

[John Erlandsson]

Thanks for replying.

I do realize the problem in joining something that doesn't exist.
But I cant find an alternative.

void *ethercat_cyclic_function()
{
    printf( "Starting cyclic thread...\n" );
    IO_digIn_t inputs;
    IO_digOut_t outputs;

    pthread_t vision_thread_ID;

    while( 1 )
    {
        time_t now = clock();
        time_t limit = now + CYCLE_TIME * CLOCKS_PER_SEC;

        /********************************
         * Update digital inputs     *
         ********************************/
        ecrt_master_receive( g_master );
        ecrt_domain_process( g_domain );

        unsigned char pdo_digIn1 = (unsigned char)EC_READ_U8( g_process_data + g_offInpMod1 );
        inputs.pushbutton = pdo_digIn1 >> 1;

        /********************************
         * Update digital outputs    *
         ********************************/
        unsigned char pdo_digOut1 = 0;
        pdo_digOut1 |= outputs.motor << 0 |
                       outputs.cylA  << 1 |
                       outputs.cylB  << 2 |
                       outputs.cylC  << 3;
        EC_WRITE_U8( g_process_data + g_offOutpMod1, pdo_digOut1 );

        ecrt_domain_queue( g_domain );
        ecrt_master_send( g_master );

        /********************************
         * Machine cycle               *
         ********************************/
        if( inputs.pushbutton )
        {
            pthread_mutex_lock( &g_vision_finished_LOCK );
            if( g_vision_finished )
            {
                pthread_join( vision_thread_ID, NULL );
                pthread_create( &vision_thread_ID, NULL, vision_thread, NULL );
            }
            pthread_mutex_unlock( &g_vision_finished_LOCK );
        }

        /********************************
         * Whait...                                       *
         ********************************/
        while( now < limit )
            now = clock();
    }
}

void *vision_thread (void *arg)
{ 
    pthread_mutex_lock(&g_vision_finished_LOCK);
    g_vision_finished = 0;
    pthread_mutex_unlock(&g_vision_finished_LOCK);
    
    printf("Inside thread\n");
    sleep(10); //Debugging dummy
    
    pthread_mutex_lock(&g_vision_finished_LOCK);
    g_vision_finished = 1;
    pthread_mutex_unlock(&g_vision_finished_LOCK);

    //return (void *)result_pipe;
    return NULL;
}

The reason why i use a thread is to prevent the vision function from blocking the cyclic task.
Should I simply skip the pthread_join and rely on my g_vision_finished variable?
I am under the impression that I need to join the thread for it to finish completely.

Thanks...

//John

[anduril462]

Check out the tutorial here: https://computing.llnl.gov/tutorials/pthreads/.

You don't really need to join:

The pthread_join() function waits for the thread specified by thread to terminate. If that thread has already terminated, then pthread_join() returns immediately. The
thread specified by thread must be joinable.

Basically, join is like calling wait() on a forked child process. It causes the current thread to do nothing until the vision thread is done. As you said, you don't want to do this, you want your cyclic task to keep running. Your if (g_vision_finished) flag will be sufficient for not creating multiple vision threads, so just ditch the pthread_join call all together, you should be fine.

EDIT: You may want a pthread_join after the cyclic work is all done, to let any last vision_thread work to be finished before your program exits.

[John Erlandsson]

Thank you!

I will ditch the join function... And i will try a semaphore instead of the vision finished variable...

//John