Linux System Programming: POSIX thread introduction Part 1

In this chapter we shall learn about:

1. Pthread Introduction.

2. Header file required for pthreads:

3. Types of threads

4. Kernel Level Threads

5. User Level Threads.

6. POSIX thread Library API:

7. How to Synchronization between threads

8. Example 1: Simple thread creation:

9. Example 2: Passing parameter to a thread

10. Joining and Detaching a thread:

11. Example 3: Simple thread creation with join system call

12. Example 4: Simple thread creation with detach system call

Pthread Introduction:

1. A thread is a light weight process.

2. It has it’s own stack and execution state, but shares the address space with it’s parent.

3. Threads are used to provide synchronization and concurrency.

4. A thread maintains its own:

–Stack pointer

–Registers

–Scheduling properties (such as policy or priority)

–Set of pending and blocked signals

–Thread specific data.

Header file required for pthreads:

#include <pthread.h>

Types of threads

There are 2 different types of threads

1. Kernel Level Threads
2. User Level Threads.

1. Kernel Level Threads

Each process contains at least one kernel thread.
Kernel maintains context information for the process and the threads.
Kernel scheduling is performed to switch between the threads.
Kernel routines can be multithreaded
Kernel threads take much longer than user threads to be swapped

2. User Level Threads.

User threads are managed and scheduled in userspace
Thread switching does not involve the kernel
ULTs can run on any OS

POSIX thread Library API:

1. To create a thread:

int pthread_create( pthread_t *pthread, const pthread_attr_t *attr, void *( *start_routine) (void *), void *arg );

pthread_create will take 4 arguments:

1. pthread: It is the thread ID.

2. attr:

Thread attributes can be:
PTHREAD_CREATE_JOINABLE,
PTHREAD_CREATE_DETACHED

When an attribute is not specified, below are the default values:
It is unbounded
It is non detached
It has a a default stack and stack size
It inherits the parent’s priority

3. Function to be called, we shall see in detail below.

4. additional arguments. We shall see in example 2.

2. To wait for a thread to finish:

int pthread_join( pthread_t thread, void **value_ptr);

3. To detach a thread:

int pthread_detach( pthread_t thread);

4. To compare two thread handles:

int pthread_equal( pthread_t thread1, pthread_t thread2);

5. To cancel a thread:

int pthread_cancel( pthread_t thread);

6. To exit a thread:

pthread_exit(void *retval);

Function prototype for a thread:

Below is the pthread_create API:

int pthread_create( pthread_t *pthread, const pthread_attr_t *attr, void *( *start_routine) (void *), void *arg );

If you look at the start routine, “void *( *start_routine) (void *)”.

It means that the function that the thread is calling should be:

1. The function should accept only 1 input parameter of the type (void *)
2. The return value type of this function is void *

Below is the function should look like:

void * start_routine( void * arg ) 
{
//statements
}

How to Synchronization between threads

Below are the different ways to create a synchronization between 2 threads:

1. Mutex variable functions
2. condition variable functions
3. pthread_once function
4. Reader Writer exclusion

Now let’s see how to create a thread:

Below are the API used to create and terminate a thread:

pthread_create (thread,attr,start_routine,arg)
pthread_exit (status)
pthread_cancel (thread)
pthread_attr_init (attr)
pthread_attr_destroy (attr)

Below are the thread attributes

Below are the resources that are shared along with the process.

Process ID, Process Group ID, and Session ID
Controlling Terminal
Credentials
Open File Descriptors
Record Locks
Signal Dispositions (making signals difficult to use)
Current Working Directory, Root Directory, etc…
Timers
Resource Limits

Below are the resources that are unique to a thread.

Thread ID
Signal Mask
errno and Condition Codes
Stack and Stack Pointer
Program Counter
General Purpose Register Values

Example 1: Simple thread creation:

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

void * thread1()
{

    printf("Hello from www.ProDeveloperTutorial.com\n");

}


int main()
{
        int status;
        pthread_t tid1;

        pthread_create(&tid1,NULL,thread1,NULL);
        return 0;
}

Example 2: Passing parameter to a thread

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <pthread.h>

//for more tutorials on C, C++, STL, DS, Linux visit www.ProDeveloperTutorial.com

 void *myFun(void *arg)
 {
   int *p;     // Pointer to an integer variable
   int x;

   p = (int *) arg;   // Casting "(void *)" type to "(int *)"
   x = *p;


   printf("\n The input parameter is %d", x );

   return(NULL);  
 }
       
 int main(int argc, char *argv[])
 {
   pthread_t      tid;
   int            param;  

   param = 12345;

   pthread_create(&tid, NULL, myFun, & param);

   pthread_join(tid, NULL); 
 }

Output:

The input parameter is 12345

Joining and Detaching a thread:

Below is the API used to join a thread:

pthread_join (threadid,status):
pthread_join is used to wait till the child thread to terminate.

Below is the API used to detaching a thread:

pthread_detach (threadid)
pthread_detach is used to delete the thread resource once the execution has been completed.

Example 3: Simple thread creation with join system call

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <pthread.h>

//for more tutorials on C, C++, STL, DS, Linux visit www.ProDeveloperTutorial.com

 void *myFun(void *arg)
 {
   printf("\nHello World !\n");

   return(NULL);
 }


 int main(int argc, char *argv[])
 {
    pthread_t  tid;

    if ( pthread_create(&tid, NULL, myFun, NULL) )
    {	   
       printf("\nCannot create thread");
       exit(1);
    }	   
 	    
    printf("\nMain now waits for thread tid to finish....") ;
 	    
    pthread_join(tid, NULL);
 	    
    exit(0);
 }