When to use pthread exit and when to use pthread join in Linux

Question

I am new to pthreads  and I am trying to understand it  I saw some examples like the following    I could see that the main   is blocked by the API pthread exit    and I have seen examples where the main function is blocked by the API pthread join    I am not able to understand when to use what    I am referring to the following site - https   computing llnl gov tutorials pthreads   I am not able to get the concept of when to use pthread join   and when to use pthread exit      Can somebody please explain  Also  a good tutorial link for pthreads will be appreciated    include  lt pthread h gt   include  lt stdio h gt   define NUM THREADS     5  void  PrintHello void  threadid       long tid     tid    long threadid     printf  Hello World  It s me  thread   ld  n   tid      pthread exit NULL      int main  int argc  char  argv         pthread t threads NUM THREADS      int rc     long t     for t 0  t lt NUM THREADS  t           printf  In main  creating thread  ld n   t         rc   pthread create  amp threads t   NULL  PrintHello   void   t         if  rc            printf  ERROR  return code from pthread create   is  d n   rc            exit -1                       Last thing that main   should do       pthread exit NULL     Realized one more thing i e     pthread cancel thread   pthread join thread  NULL     Sometimes  you want to cancel the thread while it is executing  You could do this using pthread cancel thread    However  remember that you need to enable pthread cancel support  Also  a clean up code upon cancellation   thread cleanup push my thread cleanup handler  resources   pthread setcancelstate PTHREAD CANCEL ENABLE  0    static void my thread cleanup handler void  arg         free      close  fclose

User · Answer

The pthread exit   API as has been already remarked  is used for the calling thread termination  After a call to that function a complicating clean up mechanism is started  When it completes the thread is terminated  The pthread exit   API is also called implicitly when a call to the return   routine occurs in a thread created by pthread create    Actually  a call to return   and a call to pthread exit   have the same impact  being called from a thread created by pthread create    It is very important to distinguish the initial thread  implicitly created when the main   function starts  and threads created by pthread create    A call to the return   routine from the main   function implicitly invokes the exit   system call and the entire process terminates  No thread clean up mechanism is started  A call to the pthread exit   from the main   function causes the clean up mechanism to start and when it finishes its work the initial thread terminates  What happens to the entire process  and to other threads  when pthread exit   is called from the main   function depends on the PTHREAD implementation  For example  on IBM OS 400 implementation the entire process is terminated  including other threads  when pthread exit   is called from the main   function  Other systems may behave differently  On most modern Linux machines a call to pthread exit   from the initial thread does not terminate the entire process until all threads termination  Be careful using pthread exit   from main    if you want to write a portable application  The pthread join   API is a convenient way to wait for a thread termination  You may write your own function that waits for a thread termination  perhaps more suitable to your application  instead of using pthread join    For example  it can be a function based on waiting on conditional variables  I would recommend for reading a book of David R  Butenhof    Programming with POSIX Threads     It explains the discussed topics  and more complicated things  very well  although some implementation details  such as pthread exit usage in the main function  not always reflected in the book

User · Answer

Using pthread exit in the main thread in place of pthread join   will leave the main thread in defunct zombie  state  Since not using pthread join  other joinable threads which are terminated will also remain in the zombie state and cause resource leakage      Failure to join with a thread that is joinable  i e   one that is   not    detached   produces a  zombie thread    Avoid doing this  since   each    zombie thread consumes some system resources  and when enough   zombie    threads have accumulated  it will no longer be possible to   create new    threads  or processes     Another point is keeping the main thread in the defunct state  while other threads are running may cause implementation dependent issues in various conditions like if resources are allocated in main thread or variables which are local to the main thread are used in other threads   Also  all the shared resources are released only when the process exits  it s not saving any resources  So  I think using pthread exit in place of pthread join should be avoided

User · Answer

Hmm   POSIX pthread exit description from http   pubs opengroup org onlinepubs 009604599 functions pthread exit html   After a thread has terminated  the result of access to local  auto  variables of the thread is  undefined  Thus  references to local variables of the exiting thread should not be used for  the pthread exit   value ptr parameter value    Which seems contrary to the idea that local main   thread variables will remain accessible

User · Answer

pthread exit terminates the calling thread while pthread join suspends execution of calling thread until target threads completes execution        They are pretty much well explained in detail in the open group documentation         pthread exit     pthread join

User · Answer

You don t need any calls to pthread exit 3  in your particular code   In general  the main thread should not call pthread exit  but should often call pthread join 3  to wait for some other thread to finish   In your PrintHello function  you don t need to call pthread exit because it is implicit after returning from it   So your code should rather be   void  PrintHello void  threadid       long tid    long threadid    printf  Hello World  It s me  thread   ld  n   tid     return threadid     int main  int argc  char  argv         pthread t threads NUM THREADS      int rc     intptr t t        create all the threads    for t 0  t lt NUM THREADS  t          printf  In main  creating thread  ld n    long  t        rc   pthread create  amp threads t   NULL  PrintHello   void   t        if  rc    fprintf stderr   failed to create thread   ld -  s n                                    long t  strerror rc                   exit EXIT FAILURE                           pthread yield       useful to give other threads more chance to run       join all the threads    for t 0  t lt NUM THREADS  t           printf  In main  joining thread   ld n    long  t         rc   pthread join  amp threads t   NULL         if  rc    fprintf stderr   failed to join thread   ld -  s n                                    long t  strerror rc                   exit EXIT FAILURE

User · Answer

Both methods ensure that your process doesn t end before all of your threads have ended   The join method has your thread of the main function explicitly wait for all threads that are to be  joined    The pthread exit method terminates your main function and thread in a controlled way  main has the particularity that ending main otherwise would be terminating your whole process including all other threads   For this to work  you have to be sure that none of your threads is using local variables that are declared inside them main function  The advantage of that method is that your main doesn t have to know all threads that have been started in your process  e g because other threads have themselves created new threads that main doesn t know anything about

User · Answer

pthread exit   will terminate the calling thread and exit from that but resources used by calling thread is not released to operating system if it is not detached from main thread    pthrade join   will wait or block the calling thread until target thread is not terminated  In simple word it will wait for to exit the target thread   In your code  if you put sleep or delay  in PrintHello function before pthread exit    then main thread may be exit and terminate full process  Although your PrintHello function is not completed it will terminate  If you use pthrade join    function in main before calling pthread exit   from main it will block main thread and wait to complete your calling thread  PrintHello

User · Answer

include lt stdio h gt     include lt pthread h gt     include lt semaphore h gt       sem t st     void  fun t void  arg      void  fun t void  arg              printf  quot Linux n quot           sem post  amp st            pthread exit  quot Bye quot            while 1          pthread exit  quot Bye quot            int main               pthread t pt         void  res t         if pthread create  amp pt NULL fun t NULL     -1             perror  quot pthread create quot           if sem init  amp st 0 0     0             perror  quot sem init quot           if sem wait  amp st     0             perror  quot sem wait quot           printf  quot Sanoundry n quot             Try commenting out join here         if pthread join pt  amp res t     -1             perror  quot pthread join quot           if sem destroy  amp st     0             perror  quot sem destroy quot           return 0        Copy and paste this code on a gdb  Onlinegdb would work and see for yourself  Make sure you understand once you have created a thread  the process run along with main together at the same time   Without the join  main thread continue to run and return 0 With the join  main thread would be stuck in the while loop because it waits for the thread to be done executing  With the join and delete the commented out pthread exit  the thread will terminate before running the while loop and main would continue Practical usage of pthread exit can be used as an if conditions or case statements to ensure 1 version of some code runs before exiting   void  fun t void  arg              printf  quot Linux n quot           sem post  amp st           if 2-1    1               pthread exit  quot Bye quot           else                      printf  quot We have a problem  Computer is bugged quot               pthread exit  quot Bye quot      This is redundant since the thread will exit at the end                                   of scope  But there are instances where you have a bunch                                   of else if here                  I would want to demonstrate how sometimes you would need to have a segment of code running first using semaphore in this example   include lt stdio h gt   include lt pthread h gt   include lt semaphore h gt   sem t st   void  fun t  void  arg        printf  quot I m thread n quot        sem post  amp st      int main         pthread t pt      pthread create  amp pt NULL fun t NULL       sem init  amp st 0 0       sem wait  amp st       printf  quot before thread n quot        pthread join pt NULL       printf  quot After thread n quot            Noticed how fun t is being ran after  quot before thread quot  The expected output if it is linear from top to bottom would be before thread  I m thread  after thread  But under this circumstance  we block the main from running any further until the semaphore is released by func t  The result can be verified with https   www onlinegdb com

User · Answer

As explained in the openpub documentations   pthread exit   will exit the thread that calls it    In your case since the main calls it  main thread will terminate whereas your spawned threads will continue to execute  This is mostly used in cases where the  main thread is only required to spawn threads and leave the threads to do their job  pthread join  will suspend execution of the thread that has called it unless the target thread terminates  This is useful in cases when you want to wait for thread s to terminate before further  processing in main thread

User · Answer

When pthread exit   is called  the calling threads stack is no longer addressable as  active  memory for any other thread    The  data   text and  bss parts of  static  memory allocations are still available to all other threads   Thus  if you need to pass some memory value into pthread exit   for some other pthread join   caller to see  it needs to be  available  for the thread calling pthread join   to use   It should be allocated with malloc   new  allocated on the pthread join threads stack  1  a stack value which the pthread join caller passed to pthread create or otherwise made available to the thread calling pthread exit    or 2  a static  bss allocated value   It s vital to understand how memory is managed between a threads stack  and values store in  data  bss memory sections which are used to store process wide values

[c] When to use pthread_exit() and when to use pthread_join() in Linux?

The pthread_exit() API

The pthread_join() API

Examples related to c

Examples related to linux

Examples related to pthreads