Multithreaded Programming in C: Thread Creation and Synchronization

In modern computing, multithreaded programming is a common technique that allows programs to execute multiple tasks simultaneously, thereby improving efficiency and responsiveness. The C language provides robust multithreading support through the POSIX threads (pthread) library. This article will detail how to create and manage threads in C, as well as how to synchronize them.

1. Basics of Multithreading

1.1 What is a Thread?

A process can contain multiple execution units, known as threads. Each thread has its own stack, registers, and local variables, but they share the process’s memory space. This allows multithreading to efficiently utilize resources.

1.2 Why Use Multithreading?

Concurrency: Multiple tasks can be processed simultaneously.
Resource Sharing: Different threads can access the same data, reducing memory overhead.
Responsiveness: The user interface can remain responsive even while complex calculations are being processed in the background.

2. Creating a Simple Multithreaded Program

We will start with a simple example to demonstrate how to create and run multiple threads.

2.1 Example Code

Below is a basic C program that creates two new threads, each printing a message:

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
// Thread function
void* thread_function(void* arg) {
    int thread_id = *((int*)arg);
    printf("Hello from thread %d\n", thread_id);
    return NULL;
}

int main() {
    pthread_t threads[2];
    int thread_ids[2];
    // Create two new threads
    for (int i = 0; i < 2; i++) {
        thread_ids[i] = i + 1;
        if (pthread_create(&threads[i], NULL, thread_function, &thread_ids[i]) != 0) {
            perror("Failed to create thread");
            exit(EXIT_FAILURE);
        }
    }
    // Wait for all threads to finish
    for (int i = 0; i < 2; i++) {
        pthread_join(threads[i], NULL);
    }
    printf("All threads completed.\n");
    return EXIT_SUCCESS;
}

2.2 Program Analysis

#include <pthread.h>: Includes the POSIX pthread library.
void* thread_function(void* arg): Defines a new thread function that accepts an argument and returns a pointer type.
pthread_create: Used to create a new thread. The first parameter is a pointer to a pthread_t type variable, the second parameter is for setting attributes (usually NULL), the third parameter is the function to call, and the fourth parameter is the argument to pass to that function.
pthread_join: Used to wait for a specified thread to finish and reclaim its resources.

3. Synchronization Issues in Multithreading

When multiple threads access shared data simultaneously, race conditions can occur, leading to data inconsistency. Therefore, we need to use synchronization mechanisms to protect shared resources.

3.1 Using Mutexes

A mutex is a common method used to ensure that only one thread can access a specific area or data at a time. Below, we will modify the previous example to introduce a mutex to protect access to a shared variable.

Example Code (with Mutex)

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define NUM_THREADS 5
// Global counter and mutex
int counter = 0;
pthread_mutex_t lock;

void* increment_counter(void* arg) {
   for (int i = 0; i < 10000; ++i) {
       pthread_mutex_lock(&lock); // Lock
       counter++;                  // Modify shared variable
       pthread_mutex_unlock(&lock); // Unlock
   }
   return NULL;
}

int main() {
   pthread_t threads[NUM_THREADS];
   // Initialize mutex
   if (pthread_mutex_init(&lock, NULL) != 0) {
       perror("Mutex init failed");
       return EXIT_FAILURE;
   }
   // Create multiple threads for incrementing
   for (int i = 0; i < NUM_THREADS; ++i) {
       if (pthread_create(&threads[i], NULL, increment_counter, NULL)) {
           perror("Failed to create thread");
           return EXIT_FAILURE;
       }
   }
   // Wait for all threads to finish
   for (int i = 0; i < NUM_THREADS; ++i) {
       pthread_join(threads[i], NULL);
   }
   printf("Final counter value: %d\n", counter);
   // Destroy mutex
   pthread_mutex_destroy(&lock);
   return EXIT_SUCCESS;
}

Program Analysis

In this example, we define a global countercounter and the corresponding mutexlock.
Each newly created thread attempts to increment the counter. Before modifying the counter, it locks the mutex by callingpthread_mutex_lock() to prevent other threads from modifying it simultaneously; after completion, it unlocks the mutex by callingpthread_mutex_unlock() to allow other threads to enter the critical section.

Conclusion

This article introduced the basics of multithreaded programming in C, including how to create, manage, and synchronize multiple threads. By using the POSIX standard library, we can easily implement these functionalities. In practical applications, multithreading can significantly enhance performance, but potential issues such as deadlocks and race conditions must also be considered. Therefore, when designing multithreaded applications, these factors should be carefully evaluated. I hope this article helps you better understand multithreaded programming in C!