question about the pthread.

There are codes about pthread in C

Code:

1.#include <pthread.h>
2.#include <stdlib.h>
3.#include <unistd.h>
4.void *thread_function(void *arg) {  
5.    printf("Thread says hi!\n");    
6.  return NULL;
7.}
8.int main(void) {
9.  pthread_t mythread;
10.  if ( pthread_create( &mythread, NULL, thread_function, NULL) ) {
11.   printf("error creating thread.");
12.    abort();
13.  }
14.  if ( pthread_join ( mythread, NULL ) ) {
15.   printf("error joining thread.");
16.    abort();
17.  }
18.  exit(0);
19.}

After compiling and executing i get what i expect

Code:

red 327 % gcc -o thread.out thread.c -lpthread
red 328 % thread.out
Thread says hi!
red 329 %

However, if I delete the second statement at line 14 and after compiling and executing i get

Code:

red 329 % gcc -o thread.out thread.c -lpthread
red 330 % thread.out
red 331 %

My question is why the result is like this after deleting pthread_join(mythread,NULL) and what does pthread_join do.Thanks

pthread_join() is similar in function to waitpid(). It (pthread_join) waits for the specified thread to terminate. If you don't call pthread_join(), but just exit(), then you have a race. When exit() is called, all threads are killed off (at least on modern Linuxes; if you're not running Linux, then apparently this holds for whatever you run as well). If exit() is called before the thread is able to print, you'll get no output.

It's possible that you'll actually see it print out, depending on various factors. You can force it by sleeping for a while in the main thread before you exit. The join just forces the main thread to wait until the other thread has terminated, however long that takes.

I'm not sure if POSIX specifies the exit() behavior that Linux shows, and I'm too lazy to look it up.

Did you first look up what the API does? I.e., pthread_join.

The function is used to wait for the given thread to finish. So, in your original code, main creates a thread, waits for it to finish, then exits. This is why you see the thread print out the message.

If you remove the call to this function, then main does not (have to) wait for the thread to finish. So, main creates a thread, then exists--it doesnt wait for the thread to finish executing. However, due to the non-deterministic way that CPU schedulers work, the message may or may not be printed. That is, depending on how the process/threads are scheduled, the new thread may get CPU time and be able to execute the printf statement. Other times, (more likely/often?) main will already be allotted CPU time and be able to exit right away.

To see this, just make "main" take longer. For example, in place of the join function call, put a timer for a 1 second, or even an empty loop (ie int x = 100000; while ( x-- > 0); ), and this should give the other thread time to execute, before main exits.

N.B: Ive never used pthreads, my only experience is process management in Unix, i.e. fork, etc. Ive just used intuition to imply what I said above. I imagine its quite accurate, though.

It's an error not to call pthread_join or pthread_detach on an "attached"/joinable thread. To detach the thread, either create the thread detached (via attribute) or call pthread_detach.

Returning from main() is the same as calling exit() - which kills all threads. If you don't want that behavior, then call pthread_exit a the end of main. pthread_exit never returns, thus main never returns. This will allow any remaining (detached) threads to continue to run. When all threads return the process will exit as if exit(0) was called.

gg

Thanks for your answers all.They are very useful to me know.
Tuan