Multi-threading and Concurrency in C - C Post 07

Introduction

Multi-threading and concurrency are essential for building efficient, high-performance applications. In C, multi-threading allows tasks to execute in parallel, improving resource utilization and responsiveness. In this post, we will explore POSIX threads (pthreads), thread synchronization mechanisms, race conditions, and parallel processing.

1. Understanding Threads and Concurrency

A thread is the smallest unit of execution within a process. Multi-threading enables multiple threads to run concurrently within a single program, sharing memory and resources.

1.1 Difference Between Processes and Threads

|      Feature      | Process                           | Thread                       |
|-------------------|-----------------------------------|------------------------------|
| Memory Space      | Separate                          | Shared                       |
| Creation Overhead | High                              | Low                          |
| Communication     | IPC (Inter-process communication) | Shared memory                |
| Execution Speed   | Slower due to context switching   | Faster due to shared context |

2. Creating Threads in C

C provides the POSIX Threads (pthreads) library for multi-threading.

2.1 Creating a Thread

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

void *thread_function(void *arg) {
    printf("Hello from thread!\n");
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);
    pthread_join(thread, NULL);
    return 0;
}

Explanation:

• pthread_create() initializes a new thread.
• pthread_join() waits for the thread to complete execution.

3. Synchronization Mechanisms

When multiple threads share resources, synchronization mechanisms are required to prevent data corruption.

3.1 Mutex (Mutual Exclusion)

A mutex ensures only one thread accesses a resource at a time.

pthread_mutex_t lock;

void *critical_section(void *arg) {
    pthread_mutex_lock(&lock);
    printf("Thread %ld is in the critical section\n", (long)arg);
    pthread_mutex_unlock(&lock);
    return NULL;
}

3.2 Semaphores

Semaphores control access to a resource by maintaining a counter.

#include <semaphore.h>
sem_t sem;
sem_init(&sem, 0, 1);
sem_wait(&sem);
// Critical section
sem_post(&sem);

3.3 Condition Variables

Condition variables allow threads to wait for certain conditions to be met.

pthread_cond_t cond;
pthread_mutex_t mutex;

void *thread_func(void *arg) {
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond, &mutex);
    printf("Condition met!\n");
    pthread_mutex_unlock(&mutex);
    return NULL;
}

4. Race Conditions and Deadlocks

4.1 Race Conditions

A race condition occurs when multiple threads access shared data without synchronization, leading to unpredictable results.

Example of a Race Condition:

int counter = 0;
void *increment(void *arg) {
    counter++;
}

Solution: Use mutexes to prevent simultaneous access.

4.2 Deadlocks

A deadlock occurs when two or more threads wait indefinitely for resources locked by each other.

Deadlock Example:

pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2); // Deadlock occurs if another thread locks `lock2` first

Solution: Follow a lock ordering strategy to avoid circular dependencies.

5. Parallel Processing in C

Parallel processing divides a task into multiple threads executing simultaneously to improve performance.

5.1 Example: Matrix Multiplication Using Threads

#define NUM_THREADS 4

void *multiply_row(void *arg) {
    int row = *(int *)arg;
    for (int j = 0; j < N; j++) {
        result[row][j] = 0;
        for (int k = 0; k < N; k++) {
            result[row][j] += A[row][k] * B[k][j];
        }
    }
    return NULL;
}

Benefits of Parallel Processing: Faster execution, optimized CPU usage, improved responsiveness.

Multi-threading in C enhances performance by executing tasks concurrently, but requires synchronization mechanisms like mutexes, semaphores, and condition variables to prevent race conditions and deadlocks. By implementing parallel processing, we can further optimize computational efficiency.

In the next post, we will explore system calls and file handling in C to interact with the operating system.

Happy coding! 🚀