[C/C++] – POSIX thread


Thread Basics:
  • Thread operations include thread creation, termination,
    synchronization (joins,blocking), scheduling, data management and
    process interaction.
  • A thread does not maintain a list of created threads, nor does it know the
    thread that created it.
  • All threads within a process share the same address space.
  • Threads in the same process share:
    • Process instructions
    • Most data
    • open files (descriptors)
    • signals and signal handlers
    • current working directory
    • User and group id
  • Each thread has a unique:
    • Thread ID
    • set of registers, stack pointer
    • stack for local variables, return addresses
    • signal mask
    • priority
    • Return value: errno
  • pthread functions return “0” if OK.


Thread Creation and Termination:

Example: pthread1.c

01 #include <stdio.h>
02 #include <stdlib.h>
03 #include <pthread.h>
04
05 void *print_message_function( void *ptr );
06
07 main()
08 {
09      pthread_t thread1, thread2;
10      char *message1 = "Thread 1";
11      char *message2 = "Thread 2";
12      int  iret1, iret2;
13
14     /* Create independent threads each of which will execute function */
15
16      iret1 = pthread_create( &thread1, NULL, print_message_function, (void*) message1);
17      iret2 = pthread_create( &thread2, NULL, print_message_function, (void*) message2);
18
19      /* Wait till threads are complete before main continues. Unless we  */
20      /* wait we run the risk of executing an exit which will terminate   */
21      /* the process and all threads before the threads have completed.   */
22
23      pthread_join( thread1, NULL);
24      pthread_join( thread2, NULL);
25
26      printf("Thread 1 returns: %d\n",iret1);
27      printf("Thread 2 returns: %d\n",iret2);
28      exit(0);
29 }
30
31 void *print_message_function( void *ptr )
32 {
33      char *message;
34      message = (char *) ptr;
35      printf("%s \n", message);
36 }

Compile:

  • C compiler: cc -lpthread pthread1.c

    or

  • C++ compiler: g++ -lpthread pthread1.c

 

Run: ./a.out
Results:

Thread 1
Thread 2
Thread 1 returns: 0
Thread 2 returns: 0

Details:

  • In this example the same function is used in each thread. The arguments
    are different. The functions need not be the same.
  • Threads terminate by explicitly calling pthread_exit,
    by letting the function return, or by a call to the function exit
    which will terminate the process including any threads.
  • Function call: pthread_create – create a new thread
        int pthread_create(pthread_t * thread, 
                           const pthread_attr_t * attr,
                           void * (*start_routine)(void *), 
                           void *arg);

    Arguments:

    • thread – returns the thread id. (unsigned long int defined in bits/pthreadtypes.h)
    • attr – Set to NULL if default thread attributes are used.
      (else define members of the struct pthread_attr_t defined in
      bits/pthreadtypes.h)
      Attributes include:

      • detached state (joinable? Default: PTHREAD_CREATE_JOINABLE. Other option: PTHREAD_CREATE_DETACHED)
      • scheduling policy (real-time? PTHREAD_INHERIT_SCHED,PTHREAD_EXPLICIT_SCHED,SCHED_OTHER)
      • scheduling parameter
      • inheritsched attribute (Default: PTHREAD_EXPLICIT_SCHED Inherit from parent thread: PTHREAD_INHERIT_SCHED)
      • scope (Kernel threads: PTHREAD_SCOPE_SYSTEM User threads: PTHREAD_SCOPE_PROCESS Pick one or the other not both.)
      • guard size
      • stack address (See unistd.h and bits/posix_opt.h _POSIX_THREAD_ATTR_STACKADDR)
      • stack size (default minimum PTHREAD_STACK_SIZE
        set in pthread.h),
    • void * (*start_routine) – pointer to the function to be threaded. Function has a single argument: pointer to void.
    • *arg – pointer to argument of function. To pass multiple arguments, send a pointer to a structure.
  • Function call: pthread_join – wait for termination of another thread
        int pthread_join(pthread_t th, void **thread_return);

    Arguments:

    • th – thread suspended until the thread identified by th terminates, either by calling pthread_exit() or by being cancelled.
    • thread_return – If thread_return is not NULL, the return value of th is stored in the location pointed to by thread_return.
  • Function call: pthread_exit – terminate the calling thread
        void pthread_exit(void *retval);

    Arguments:

    • retval – Return value of thread.

    This routine kills the thread. The pthread_exit function never
    returns. If the thread is not detached, the thread id and return value
    may be examined from another thread by using pthread_join.

    Note: the return pointer *retval, must not be of local scope
    otherwise it would cease to exist once the thread terminates.

  • [C++ pitfalls]: The above sample program
    will compile with the GNU C and C++ compiler g++.
    The following function pointer representation below
    will work for C but not C++. Note the subtle differences and avoid the
    pitfall below:
    1 void print_message_function( void *ptr );
    2 ...
    3 ...
    4 iret1 = pthread_create( &thread1, NULL, (void*)&print_message_function, (void*) message1);
    5 ...
    6 ...


Thread Synchronization:

The threads library provides three synchronization mechanisms:

  • mutexes – Mutual exclusion lock: Block access to variables
    by other threads. This enforces exclusive access by a thread to a
    variable or set of variables.
  • joins – Make a thread wait till others are complete (terminated).
  • condition variables – data type pthread_cond_t

Mutexes:

Mutexes are used to prevent data inconsistencies due to operations by multiple
threads upon the same memory area performed at the same time or to prevent race conditions where an order of operation upon the memory is expected.
A contention or race condition often occurs when two or more threads need to perform operations on the same
memory area, but the results of computations depends on
the order in which these operations are performed. Mutexes are used for
serializing shared resources such as memory. Anytime a global resource is accessed by more
than one thread the resource should have a Mutex associated with it.
One can apply a mutex to protect a segment of memory (“critical region”) from other threads.
Mutexes can be applied only to threads in a single process and do not work
between processes as do semaphores.

Example threaded function:

Without Mutex With Mutex
1 int counter=0;
2
3 /* Function C */
4 void functionC()
5 {
6
7    counter++
8
9 }
01 /* Note scope of variable and mutex are the same */
02 pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
03 int counter=0;
04
05 /* Function C */
06 void functionC()
07 {
08    pthread_mutex_lock( &mutex1 );
09    counter++
10    pthread_mutex_unlock( &mutex1 );
11 }
Possible execution sequence
Thread 1 Thread 2 Thread 1 Thread 2
counter = 0 counter = 0 counter = 0 counter = 0
counter = 1 counter = 1 counter = 1 Thread 2 locked out.

Thread 1 has exclusive use of variable counter

counter = 2

If register load and store operations for the incrementing of variable counter
occurs with unfortunate timing, it is theoretically possible to have each
thread increment and overwrite the same variable with the same value.
Another possibility is that thread two would first increment counter
locking out thread one until complete and then thread one would increment it to 2.

Sequence Thread 1 Thread 2
1 counter = 0 counter=0
2 Thread 1 locked out.

Thread 2 has exclusive use of variable counter

counter = 1
3 counter = 2

Code listing: mutex1.c

 

01 #include <stdio.h>
02 #include <stdlib.h>
03 #include <pthread.h>
04
05 void *functionC();
06 pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
07 int  counter = 0;
08
09 main()
10 {
11    int rc1, rc2;
12    pthread_t thread1, thread2;
13
14    /* Create independent threads each of which will execute functionC */
15
16    if( (rc1=pthread_create( &thread1, NULL, &functionC, NULL)) )
17    {
18       printf("Thread creation failed: %d\n", rc1);
19    }
20
21    if( (rc2=pthread_create( &thread2, NULL, &functionC, NULL)) )
22    {
23       printf("Thread creation failed: %d\n", rc2);
24    }
25
26    /* Wait till threads are complete before main continues. Unless we  */
27    /* wait we run the risk of executing an exit which will terminate   */
28    /* the process and all threads before the threads have completed.   */
29
30    pthread_join( thread1, NULL);
31    pthread_join( thread2, NULL);
32
33    exit(0);
34 }
35
36 void *functionC()
37 {
38    pthread_mutex_lock( &mutex1 );
39    counter++;
40    printf("Counter value: %d\n",counter);
41    pthread_mutex_unlock( &mutex1 );
42 }

Compile: cc -lpthread mutex1.c

Run: ./a.out

Results:

Counter value: 1
Counter value: 2

When a mutex lock is attempted against a mutex which is held by another thread,
the thread is blocked until the mutex is unlocked.
When a thread terminates, the mutex does not unless explicitly unlocked.
Nothing happens by default.

Man Pages:

  • pthread_mutex_lock() – acquire a lock on the specified mutex variable. If the mutex is already locked by another thread, this call will block the calling thread until the mutex is unlocked.
  • pthread_mutex_unlock() – unlock a mutex variable. An error is returned if mutex is already unlocked or owned by another thread.
  • pthread_mutex_trylock() – attempt to lock a mutex or will return error code if busy. Useful for preventing deadlock conditions.

Joins:

A join is performed when one wants to wait for a thread to finish. A thread
calling routine may launch multiple threads then wait for them to finish
to get the results. One waits for the completion of the threads with a join.

Sample code: join1.c

01 #include <stdio.h>
02 #include <pthread.h>
03
04 #define NTHREADS 10
05 void *thread_function(void *);
06 pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
07 int  counter = 0;
08
09 main()
10 {
11    pthread_t thread_id[NTHREADS];
12    int i, j;
13
14    for(i=0; i < NTHREADS; i++)
15    {
16       pthread_create( &thread_id[i], NULL, thread_function, NULL );
17    }
18
19    for(j=0; j < NTHREADS; j++)
20    {
21       pthread_join( thread_id[j], NULL);
22    }
23   
24    /* Now that all threads are complete I can print the final result.     */
25    /* Without the join I could be printing a value before all the threads */
26    /* have been completed.                                                */
27
28    printf("Final counter value: %d\n", counter);
29 }
30
31 void *thread_function(void *dummyPtr)
32 {
33    printf("Thread number %ld\n", pthread_self());
34    pthread_mutex_lock( &mutex1 );
35    counter++;
36    pthread_mutex_unlock( &mutex1 );
37 }

Compile: cc -lpthread join1.c

Run: ./a.out
Results:

Thread number 1026
Thread number 2051
Thread number 3076
Thread number 4101
Thread number 5126
Thread number 6151
Thread number 7176
Thread number 8201
Thread number 9226
Thread number 10251
Final counter value: 10

Man Pages:


Condition Variables:

A condition variable is a variable of type pthread_cond_t and is
used with the appropriate functions for waiting and later, process continuation.
The condition variable mechanism allows threads to suspend execution and
relinquish the processor until some condition is true.
A condition variable must always be associated with a mutex
to avoid a race condition created by one thread preparing to wait and another
thread
which may signal the condition before the first thread actually waits on it
resulting in a deadlock.
The thread will be perpetually waiting for a signal that is never sent.
Any mutex can be used, there is no explicit link between the mutex and the
condition variable.

Man pages of functions used in conjunction with the condition variable:

Example code: cond1.c

01 #include <stdio.h>
02 #include <stdlib.h>
03 #include <pthread.h>
04
05 pthread_mutex_t count_mutex     = PTHREAD_MUTEX_INITIALIZER;
06 pthread_cond_t  condition_var   = PTHREAD_COND_INITIALIZER;
07
08 void *functionCount1();
09 void *functionCount2();
10 int  count = 0;
11 #define COUNT_DONE  10
12 #define COUNT_HALT1  3
13 #define COUNT_HALT2  6
14
15 main()
16 {
17    pthread_t thread1, thread2;
18
19    pthread_create( &thread1, NULL, &functionCount1, NULL);
20    pthread_create( &thread2, NULL, &functionCount2, NULL);
21
22    pthread_join( thread1, NULL);
23    pthread_join( thread2, NULL);
24
25    printf("Final count: %d\n",count);
26
27    exit(0);
28 }
29
30 // Write numbers 1-3 and 8-10 as permitted by functionCount2()
31
32 void *functionCount1()
33 {
34    for(;;)
35    {
36       // Lock mutex and then wait for signal to relase mutex
37       pthread_mutex_lock( &count_mutex );
38
39       // Wait while functionCount2() operates on count
40       // mutex unlocked if condition varialbe in functionCount2() signaled.
41       pthread_cond_wait( &condition_var, &count_mutex );
42       count++;
43       printf("Counter value functionCount1: %d\n",count);
44
45       pthread_mutex_unlock( &count_mutex );
46
47       if(count >= COUNT_DONE) return(NULL);
48     }
49 }
50
51 // Write numbers 4-7
52
53 void *functionCount2()
54 {
55     for(;;)
56     {
57        pthread_mutex_lock( &count_mutex );
58
59        if( count < COUNT_HALT1 || count > COUNT_HALT2 )
60        {
61           // Condition of if statement has been met.
62           // Signal to free waiting thread by freeing the mutex.
63           // Note: functionCount1() is now permitted to modify "count".
64           pthread_cond_signal( &condition_var );
65        }
66        else
67        {
68           count++;
69           printf("Counter value functionCount2: %d\n",count);
70        }
71
72        pthread_mutex_unlock( &count_mutex );
73
74        if(count >= COUNT_DONE) return(NULL);
75     }
76
77 }

Compile: cc -lpthread cond1.c

Run: ./a.out

Results:

Counter value functionCount1: 1
Counter value functionCount1: 2
Counter value functionCount1: 3
Counter value functionCount2: 4
Counter value functionCount2: 5
Counter value functionCount2: 6
Counter value functionCount2: 7
Counter value functionCount1: 8
Counter value functionCount1: 9
Counter value functionCount1: 10
Final count: 10

Note that functionCount1() was halted while count was between the values COUNT_HALT1 and COUNT_HALT2.
The only thing that has been ensures is that functionCount2 will
increment the count between the values COUNT_HALT1 and COUNT_HALT2.
Everything else is random.

The logic conditions (the “if” and “while” statements) must be chosen to
insure that the “signal” is executed if the “wait” is ever processed.
Poor software logic can also lead to a deadlock condition.

Note: Race conditions abound with this example because count is used as the
condition and can’t be locked in the while statement without causing deadlock.


Thread Scheduling:

When this option is enabled, each thread may have its own scheduling properties.
Scheduling attributes may be specified:

  • during thread creation
  • by dynamically by changing the attributes of a thread already created
  • by defining the effect of a mutex on the thread’s scheduling when creating a mutex
  • by dynamically changing the scheduling of a thread during synchronization operations.

The threads library provides default values that are sufficient for most cases.


Thread Pitfalls:
  • Race conditions: While the code may appear on the screen in the order
    you wish the code to execute, threads are scheduled by the operating
    system and are executed at random. It cannot be assumed that threads
    are executed in the order they are created. They may also execute at
    different speeds. When threads are executing (racing to complete) they
    may give unexpected results (race condition). Mutexes and joins must be
    utilized to achieve a predictable execution order and outcome.
  • Thread safe code: The threaded routines must call functions which are
    “thread safe”. This means that there are no static or global variables which
    other threads may clobber or read assuming single threaded operation.
    If static or global variables are used then mutexes must be applied or
    the functions must be re-written to avoid the use of these variables.
    In C, local variables are dynamically allocated on the stack.
    Therefore, any function that does not use static data or other shared
    resources is thread-safe. Thread-unsafe functions may be used by only one
    thread at a time in a program and the uniqueness of the thread must be
    ensured.
    Many non-reentrant functions return a pointer to static data.
    This can be avoided by returning dynamically allocated data or
    using caller-provided storage.
    An example of a non-thread safe function is strtok which is also
    not re-entrant. The “thread safe” version is the re-entrant version
    strtok_r.
  • Mutex Deadlock: This condition occurs when a mutex is applied but then not
    “unlocked”. This causes program execution to halt indefinitely.
    It can also be caused by poor application of mutexes or joins.
    Be careful when applying two or more mutexes to a section of code.
    If the first pthread_mutex_lock is applied and the second pthread_mutex_lock
    fails due to another thread applying a mutex, the first mutex
    may eventually lock all other threads from accessing data including the
    thread which holds the second mutex. The threads
    may wait indefinitely for the resource to become free causing a deadlock.
    It is best to test and if failure occurs, free the resources and stall
    before retrying.

    01 ...
    02 pthread_mutex_lock(&mutex_1);
    03 while ( pthread_mutex_trylock(&mutex_2) )  /* Test if already locked   */
    04 {
    05    pthread_mutex_unlock(&mutex_1);  /* Free resource to avoid deadlock */
    06    ...
    07    /* stall here   */
    08    ...
    09    pthread_mutex_lock(&mutex_1);
    10 }
    11 count++;
    12 pthread_mutex_unlock(&mutex_1);
    13 pthread_mutex_unlock(&mutex_2);
    14 ...

    The order of applying the mutex is also important. The following code
    segment illustrates a potential for deadlock:

    01 void *function1()
    02 {
    03    ...
    04    pthread_mutex_lock(&lock1);           // Execution step 1
    05    pthread_mutex_lock(&lock2);           // Execution step 3 DEADLOCK!!!
    06    ...
    07    ...
    08    pthread_mutex_lock(&lock2);
    09    pthread_mutex_lock(&lock1);
    10    ...
    11 }
    12
    13 void *function2()
    14 {
    15    ...
    16    pthread_mutex_lock(&lock2);           // Execution step 2
    17    pthread_mutex_lock(&lock1);
    18    ...
    19    ...
    20    pthread_mutex_lock(&lock1);
    21    pthread_mutex_lock(&lock2);
    22    ...
    23 }
    24
    25 main()
    26 {
    27    ...
    28    pthread_create(&thread1, NULL, function1, NULL);
    29    pthread_create(&thread2, NULL, function2, NULL);
    30    ...
    31 }

    If function1 acquires the first mutex and function2
    acquires the second, all resources are tied up and locked.

  • Condition Variable Deadlock:
    The logic conditions (the “if” and “while” statements) must be chosen to
    insure that the “signal” is executed if the “wait” is ever processed.

Reference Source :  http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: