POSIX Threads

Hello there,

I try to use pthread_create function, but my start routine should return a value, so how can I get that return?

for instance how would I create a thread with that function below and how would I call the pthread_create function?


int the_routine ( int number)
{
....
return total;
}



pthread_create( &thread1, NULL, the_routine?, the_parameter?);

In my opinion you should to do next:

int the_routine ( int number)
{
....
return total;
}

void my_thread(int param)
{
int res = the_routine(param);
///check res value here
}

pthread_create( &thread1, NULL, my_thread, the_parameter?);

The following quotations contain trivial edits.

Originally Posted by embesil Hello there, I try to use pthread_create function, but my start routine should return a value, so how can I get that return? for instance how would I create a thread with that function below and how would I call the pthread_create function? int the_routine ( int number) { .... return total; } pthread_create( &thread1, NULL, the_routine?, the_parameter?);

Originally Posted by alex1983-0112 In my opinion you should to do next: int the_routine ( int number) { .... return total; } void my_thread(int param) { int res = the_routine(param); ///check res value here } pthread_create( &thread1, NULL, my_thread, the_parameter?);

alex1983-0112's answer makes a good point, but it would be well to explore this question:

If I have a parent thread which fires off child threads and needs to know their status upon completion so it can coordinate the start of other threads, how does the parent thread receive that status from them?

This is a fairly routine task in designing code using POSIX threads, which provides a fairly easy way to take care of it. Three fairly easy ways, in fact.

1. The first way is used if the parent thread doesn't want to wait for the child thread to finish, because the parent thread has other things to do, and just wants to check back periodically to see whether the child thread is finished, without waiting for it.
   
   First, please note that the final parameter to pthread_create() is not of type int; it's of type void *. The same is true of the parameter to the child main function! The parent thread can pass NULL if it wants, but often a programmer will call malloc() in the parent thread to create an instance of some struct that he has defined, and then fill that with values he wants the child thread to use. In this struct, he can even declare one of the fields an int, call it something like am_i_done_yet, and set it to zero. He can declare another field whatever type of value he wants the child thread to return and call it something like child_result. He doesn't need to set it to any particular value. When the child thread is done, it will modify first the child_result field and second the am_i_done_yet field (since there is no guarantee that he won't be time-sliced between setting the two values).
   
   Then every once in a while the parent thread can check the am_i_done_yet field to see whether the child thread is done. If so, it can then just pick up the returned value from the child_result field.
   
   Once the parent thread knows that the child thread is done, it can call pthread_join(), confident that it won't have to wait any significant amount of time. It should definitely do so, because otherwise the child thread (even though it's no longer running) retains certain system resources for no good reason.
   
   If the parent thread doesn't want to call pthread_join() when it knows that the child thread is done, it can create the thread detached in the first place.
   
   In any event, the parent thread should free() the parameter block when it's done with it, or memory leak will occur.
   
   
2. The second method is used when the parent thread simply wants to wait until the child thread is finished, rather than checking periodically to see whether the child thread is finished, because the parent thread simply has no other work to do or coordination of child threads to perform.
   
   The second method is like the first, with these changes.
   
   
   1. Don't define an am_i_done_yet field. Don't define a child_result field either.
      
      
   2. Please note that the type of a child thread's main function is not int, but void *. The child thread's main function can return NULL, or it can malloc() an instance of some struct which it fills with the desired result before finishing.
      
      
   3. When it's done, either the child thread passes the pointer to this struct (or NULL) to pthread_exit(), or uses that pointer as the parameter of a return statement from the main function in the child thread.
      
      
   4. The parent process, meanwhile, instead of checking am_i_done_yet periodically, simply calls pthread_join() when it's ready to wait for the result. The second parameter to pthread_join() is of type void **. So you use it like this:
      

      void *child_result;
      ...
      if(pthread_join(child_thread_identifier,&child_result)!=0)
      {
        /* Put code to recover from any pthread_join() error here. */
      }

   5. The parent then picks up whatever values it wants from the result fields, and then free()s that area, so that memory leak does not occur. As in the first way, it also needs to free() the original parameter struct it passed to the child thread.
   
   
3. The third way is a blending of the first two. Like the second way, it has the parent thread waiting for the child to finish. But it uses a child_result field to pass back the results, rather than doing a malloc() in the child for a results struct and an additional free() in the parent for this struct. Note, however, that the parent still has to free() the original parameter struct() passed to the child when it started the child.

Hope this helps.

@wje_lq: well, first of all I should say that I appreciated your answer

I have another question. I have a function gets 2 parameters. So, can I just write
pthread_create(&tid,&attr, function, parameter1, parameter2);

thank you

The following quotation contains trivial edits.

Originally Posted by embesil can I just write pthread_create(&tid,&attr, function, parameter1, parameter2);

No, unfortunately. Put 'em in a struct. Use malloc(), and don't forget to use free() in your parent thread when you're all done with that child thread. Or you can do the free() in your child thread if you want, if the parent thread has no more use for that struct.