The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Multithreading in C

Next ►
►

Multithreading is a powerful technique that allows a program to perform multiple tasks concurrently, improving performance and responsiveness. In C, multithreading is typically achieved using the POSIX Threads (pthread) library. This section will cover the basics of multithreading, including creating and managing threads, synchronization mechanisms, and practical examples.

Key Concepts

  1. Thread: A thread is the smallest unit of a process that can be scheduled for execution. It shares the process's resources but operates independently.
  2. POSIX Threads (pthreads): A standard for thread creation and synchronization in C, providing a set of APIs for multithreading.

Creating and Managing Threads

Creating a Thread

To create a thread in C, you use the pthread_create function. Here's the syntax:

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
  • thread: A pointer to a pthread_t variable that will hold the thread ID.
  • attr: A pointer to a pthread_attr_t structure that specifies thread attributes (can be NULL for default attributes).
  • start_routine: A pointer to the function that the thread will execute.
  • arg: A pointer to the argument passed to the start_routine function.

Example: Creating a Simple Thread

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

void *print_message(void *arg) {
    char *message = (char *)arg;
    printf("%s\n", message);
    return NULL;
}

int main() {
    pthread_t thread;
    char *message = "Hello, World from Thread!";
    
    if (pthread_create(&thread, NULL, print_message, (void *)message)) {
        fprintf(stderr, "Error creating thread\n");
        return 1;
    }
    
    if (pthread_join(thread, NULL)) {
        fprintf(stderr, "Error joining thread\n");
        return 2;
    }
    
    return 0;
}

Explanation

  • pthread_create: Creates a new thread that executes the print_message function.
  • pthread_join: Waits for the thread to terminate. This ensures the main thread waits for the created thread to finish before exiting.

Synchronization Mechanisms

When multiple threads access shared resources, synchronization is crucial to avoid race conditions and ensure data consistency. Common synchronization mechanisms include mutexes and condition variables.

Mutexes

A mutex (mutual exclusion) is a locking mechanism that ensures only one thread can access a resource at a time.

Example: Using Mutexes

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

pthread_mutex_t lock;
int counter = 0;

void *increment_counter(void *arg) {
    pthread_mutex_lock(&lock);
    counter++;
    printf("Counter: %d\n", counter);
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    pthread_t threads[10];
    pthread_mutex_init(&lock, NULL);
    
    for (int i = 0; i < 10; i++) {
        if (pthread_create(&threads[i], NULL, increment_counter, NULL)) {
            fprintf(stderr, "Error creating thread\n");
            return 1;
        }
    }
    
    for (int i = 0; i < 10; i++) {
        if (pthread_join(threads[i], NULL)) {
            fprintf(stderr, "Error joining thread\n");
            return 2;
        }
    }
    
    pthread_mutex_destroy(&lock);
    return 0;
}

Explanation

  • pthread_mutex_lock: Locks the mutex, ensuring exclusive access to the critical section.
  • pthread_mutex_unlock: Unlocks the mutex, allowing other threads to access the critical section.
  • pthread_mutex_init: Initializes the mutex.
  • pthread_mutex_destroy: Destroys the mutex.

Practical Exercise

Exercise: Implement a Multithreaded Counter

Task: Create a program that spawns 5 threads, each incrementing a shared counter 1000 times. Use mutexes to ensure thread-safe access to the counter.

Solution:

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

#define NUM_THREADS 5
#define INCREMENTS 1000

pthread_mutex_t lock;
int counter = 0;

void *increment_counter(void *arg) {
    for (int i = 0; i < INCREMENTS; i++) {
        pthread_mutex_lock(&lock);
        counter++;
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    pthread_mutex_init(&lock, NULL);
    
    for (int i = 0; i < NUM_THREADS; i++) {
        if (pthread_create(&threads[i], NULL, increment_counter, NULL)) {
            fprintf(stderr, "Error creating thread\n");
            return 1;
        }
    }
    
    for (int i = 0; i < NUM_THREADS; i++) {
        if (pthread_join(threads[i], NULL)) {
            fprintf(stderr, "Error joining thread\n");
            return 2;
        }
    }
    
    printf("Final Counter Value: %d\n", counter);
    pthread_mutex_destroy(&lock);
    return 0;
}

Explanation

  • NUM_THREADS: Number of threads to create.
  • INCREMENTS: Number of times each thread increments the counter.
  • increment_counter: Function executed by each thread, incrementing the counter in a thread-safe manner.

Common Mistakes and Tips

  • Forgetting to join threads: Always use pthread_join to ensure the main thread waits for all threads to complete.
  • Not using mutexes: Always use mutexes or other synchronization mechanisms when accessing shared resources.
  • Deadlocks: Avoid deadlocks by ensuring that all mutexes are unlocked in the correct order.

Conclusion

In this section, you learned the basics of multithreading in C using the POSIX Threads library. You now know how to create and manage threads, use mutexes for synchronization, and avoid common pitfalls. Multithreading can significantly improve the performance and responsiveness of your programs, but it requires careful management of shared resources to avoid issues like race conditions and deadlocks.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved