Introduction to synchronization using mutexes

• if multiple threads are simply reading the same variable, there is no problem.

• however, if multiple threads update the same variable, the order of those updates - the order in which the threads execute - is important as it affects the values of the variable, over time, and the final value of that variable.

Thread libraries support an abstraction named a mutex, an abbreviation of mutual exclusion. Mutex variables are one of the primary means providing synchronization of threads - the order in which they execute - and for protecting shared data when multiple writes can occur.

A mutex variable acts like a lock protecting access to a shared data resource.

The basic concept of a mutex as used in pthreads is that only one thread can lock (or own) a mutex variable at any given time.

Thus, even if several threads try to lock a mutex only one thread will be successful. No other thread can own that mutex until the owning thread unlocks that mutex. Threads must take turns accessing protected data.

Race conditions

In the above example, a mutex variable should be used to lock the balance (variable) while a thread is using this shared resource. Threads owning a mutex typically update global variable(s). When used correctly, the final result (value) is the same as would be observed if all updates were made by a single-threaded program.

The variables being updated belong to a critical section.

A typical sequence when using a mutex is as follows:

• create and initialize a single mutex variable (shared by all threads),
• several threads attempt to lock the mutex,
• only one thread succeeds and that thread owns the mutex,
• the owner thread performs some actions (such as updating a variable),
• the owner unlocks the mutex,
• another thread acquires the mutex and repeats the sequence, and
• finally, the mutex is destroyed.

An example using a mutex

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

int balance = 0;

pthread_mutex_t mutexbalance = PTHREAD_MUTEX_INITIALIZER;

void deposit(int amount)
{
    pthread_mutex_lock(&mutexbalance);
    {
        int currbalance = balance;      // read shared balance
        currbalance    += amount;
        balance         = currbalance;  // write shared balance
    }
    pthread_mutex_unlock(&mutexbalance);
}

void withdraw(int amount)
{
    pthread_mutex_lock(&mutexbalance);
    {
        int currbalance = balance;       // read shared balance
        if(currbalance >= amount) {
            currbalance -= amount;
            balance      = currbalance;  // write shared balance
        }
    }
    pthread_mutex_unlock(&mutexbalance);
}

    create threads...
....
    deposit(200);      // thread 1
    withdraw(100);     // thread 2
    deposit(500);      // thread 1
    withdraw(200);     // thread 3

Pthreads functions to manage mutexes

Creating and destroying:

Locking and unlocking:

Condition variables

Without condition variables, we would require threads to continually poll (possibly in a critical section), to check if a condition is met - very resource intensive! A condition variable helps avoid the polling.

A condition variable is always used in conjunction with a mutex lock.
Consider this sequence in which threadB informs threadA when a required condition is met:

main thread:

Pthreads functions to manage condition variables

Creating and destroying:

Waiting and signalling:

A condition variable example

This is a very typical problem requiring synchronization as we don't wish either thread to block indefinitely waiting for the other, and the consumer should only execute when it's known that there's at least one new item available:

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

#define MAX_ITEMS     10

pthread_cond_t cond_recv    = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_send    = PTHREAD_COND_INITIALIZER;

pthread_mutex_t cond_mutex  = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;

bool full=false;
int  count=0;

void *producer(void *thread_id)
{
    while(true) {
	pthread_mutex_lock(&cond_mutex);
        while(full) {
            pthread_cond_wait(&cond_recv, &cond_mutex) ;
        }

        pthread_mutex_unlock(&cond_mutex);
        pthread_mutex_lock(&count_mutex);

        ++count;
        full = true;
        printf("producer(%li):%i\n", pthread_self() , count);

        pthread_cond_broadcast(&cond_send);
        pthread_mutex_unlock(&count_mutex);

        if((count >= MAX_ITEMS) {
            break;
        }
    }
}

void *consumer(void *thread_id)
{
    while(true) {
        pthread_mutex_lock(&cond_mutex);

        while(!full) {
            pthread_cond_wait(&cond_send , &cond_mutex) ;
        }

        pthread_mutex_unlock(&cond_mutex);
        pthread_mutex_lock(&count_mutex);

        --count;
        full = false;
        printf("consumer(%li):%i\n", pthread_self(), count);

        pthread_cond_broadcast(&cond_recv);
        pthread_mutex_unlock(&count_mutex);

        if((count >= MAX_ITEMS) {
            break;
        }
    }
}

Thread support in C11

Threading support has been long overdue in the standard C language specification, and it was finally defined in C11.

Before that, the POSIX threads API was used as the primary tool to utilize multi-threaded programming. Since C11 provided a more standard interface that could be used without platform dependencies, it has been recommended to use the ISO language API than the POSIX version. Although the two APIs don't match in their function prototypes, the main features are very similar.

Note that all additions have been to the standard C11 library, and have not added new keywords to the language.

Some helpful references:

• cppreference.com

• Youtube video by Wade Huber (10 minutes).

• Discussion comparing POSIX threads and C11 threads [Reddit.com]