pthread execution on linux

I started doing pthread programming on linux and at the very first programme i got totally confused. Below is the programme I am running

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *print_message_function( void *ptr );

int main(){
 pthread_t thread1, thread2;
 char *message1 = "Thread 1";
 char *message2 = "Thread 2";
 int  iret1, iret2;

/* Create independent threads each of which will execute function */

 iret1 = pthread_create( &thread1, NULL, print_message_function, (void*) message1);
 iret2 = pthread_create( &thread2, NULL, print_message_function, (void*) message2);

 /* Wait till threads are complete before main continues. Unless we  */
 /* wait we run the risk of executing an exit which will terminate   */
 /* the process and all threads before the threads have completed.   */

 pthread_join( thread1, NULL);
 printf("amit");
 pthread_join( thread2, NULL); 

 printf("Thread 1 returns: %d\n",iret1);
 printf("Thread 2 returns: %d\n",iret2);
 exit(0);
}

void *print_message_function( void *ptr ){
 char *message;
 message = (char *) ptr;
 printf("%s \n", message);
}

First one thing i would like to know is order of thread execution is not sequential ??

Second thing is i intensionally put print("amit"); to see main is really halt during thread1 getting terminated but in the output what we can see is printf statement is executed first. The output of whole process is

Thread 1

Thread 2

amitThread 1 returns: 0

Thread 2 returns: 0

You are right in saying that the order of thread execution is not sequential. To some extent, that is the whole point of using threads, i.e. to run other tasks concurrently.

The output you are seeing is as expected, and can possibly be different.

Perhaps this will help:

   main            thread1     thread2
    |                
    |--create--------+-----------\
    |                |           |   
    |            "Thread 1"      |   "Thread 2" can
    |                |           |<- occur anywhere
    |               /            |   along this line
   join(1) ---------             |
    |                            |
    |                            |
  "amit"                         |
    |                            |
    |                            |
   join(2) ---------------------/
    |
    |
"Thread 1 returns"
"Thread 2 returns"
    |
  exit(0)

The only guarantee you have is:

• "Thread 1" will always be printed before "amit" (because pthread_join() waits for thread 1 to end before the main program can proceed)
• "Thread X returns ..." statements will always come at the end, after both threads have terminated.

First one thing i would like to know is order of thread execution is not sequential ?

Not normally. Threads on most modern operating systems (early threading implementations on Linux used cooperative multitasking) execute in parallel and the order in which your printfs get executed is partially non deterministic. The pthread_joins impose some ordering on things, so:

• Thread 1 must come before Amit because the main thread waits for thread 1 to finish before printing Amit1
• Thread 2 must come before Thread 1 returns: because of the second pthread_join. All of the printfs in main appear in the order they appear in main.

I hope that answers your question. I'm not entirely sure what you were asking but feel free to ask for clarification on any point.