Basics of multithreading in C

Multithreading in C refers to the concurrent execution of multiple threads within a single program. Threads are lightweight processes that share the same memory space and resources, enabling efficient parallelism in a program. Multithreading is used to perform tasks concurrently, making better use of multi-core processors and improving application responsiveness.

There are two main ways to implement multithreading in C:

  1. Using threads: Threads are lightweight processes that share the same memory space. They can be used to run multiple tasks simultaneously without having to create a new process for each task.
  2. Using processes: Processes are heavyweight units of execution that have their own memory space. They can be used to run multiple tasks simultaneously, but this approach is less efficient than using threads because each process must have its own copy of the program code and data.

Multithreading Library

In C, multithreading is typically implemented using a library like the POSIX Threads (pthread) library. This library provides functions and data structures for creating, managing, and synchronizing threads.

To create a thread in C, you can use the pthread_create() function. This function takes three arguments:

  1. A pointer to a variable that will store the ID of the new thread.
  2. A pointer to a structure that specifies the attributes of the new thread. If this argument is NULL, then the default attributes will be used.
  3. A pointer to a function that will be executed by the new thread.
Basic Multithreading Example

Below is a simple example of creating and running two threads using the pthread library. The threads print messages concurrently.

#include <stdio.h> #include <pthread.h> void *thread_function(void *arg) { char *message = (char *)arg; for (int i = 0; i < 5; i++) { printf("%s\n", message); } return NULL; } int main() { pthread_t thread1, thread2; char *message1 = "Thread 1"; char *message2 = "Thread 2"; // Create two threads pthread_create(&thread1, NULL, thread_function, (void *)message1); pthread_create(&thread2, NULL, thread_function, (void *)message2); // Wait for threads to finish pthread_join(thread1, NULL); pthread_join(thread2, NULL); return 0; }

In this example, pthread_create is used to create two threads, each running the thread_function. The pthread_join function is used to wait for the threads to finish.

Thread Synchronization

Multithreading can lead to race conditions and other synchronization issues. Mutexes (short for "mutual exclusion") are often used to protect critical sections of code from being accessed by multiple threads simultaneously. Here's an example of using a mutex to protect a shared variable:

#include <stdio.h> #include <pthread.h> pthread_mutex_t mutex; int shared_variable = 0; void *increment_thread(void *arg) { for (int i = 0; i < 100000; i++) { pthread_mutex_lock(&mutex); shared_variable++; pthread_mutex_unlock(&mutex); } return NULL; } int main() { pthread_t thread1, thread2; pthread_mutex_init(&mutex, NULL); pthread_create(&thread1, NULL, increment_thread, NULL); pthread_create(&thread2, NULL, increment_thread, NULL); pthread_join(thread1, NULL); pthread_join(thread2, NULL); printf("Final shared_variable value: %d\n", shared_variable); pthread_mutex_destroy(&mutex); return 0; }

In this example, we use a mutex (pthread_mutex_t) to protect the shared variable shared_variable from concurrent access. The threads increment the variable while holding the mutex to ensure exclusive access.

Thread Termination and Cleanup

It's important to manage thread termination and cleanup. Properly ending threads and releasing allocated resources is crucial. The pthread_exit function and pthread_cancel function can be used for thread termination. Also, pthread_join is used to wait for a thread to finish.

Error Handling

Error handling is crucial in multithreaded programs. The pthread functions return error codes, which should be checked for error conditions.


Multithreading in C allows you to take advantage of modern multicore processors and execute tasks concurrently, potentially improving performance and responsiveness in your programs. However, it also introduces complexities such as race conditions and synchronization issues, which must be carefully managed using synchronization mechanisms like mutexes and proper error handling.