Basics of Multithreading in C

C programs run on a single thread by default - meaning only one instruction is executed at a time. But what if you need to perform multiple tasks simultaneously? For example, a graphical interface must remain responsive even while performing time-consuming operations in the background. This is where multithreading comes in.

Note: Multithreading is different from asynchronous programming, which allows a single thread to handle multiple tasks without blocking.

🧵 What Is a Thread?

A thread is a single sequence of instructions within a process. Each process starts with one thread, but it can create additional threads that run concurrently. These threads share the same memory space, making communication between them efficient, but also introducing risks like race conditions.

🔧 Creating a Thread in C

Let’s dive into how to use threads in C.

On POSIX systems (like Linux), the pthread library provides thread functionality. To use it, you must link your program with -lpthread. For example:

gcc -o main main.c -lpthread 

Here’s a simple program that creates and runs a thread:

#include <pthread.h> #include <unistd.h> #include <stdio.h>  void* wait_fn(void* arg) { sleep(2); printf("Done.\n"); return NULL; } int main() { pthread_t thread; int err = pthread_create(&thread, NULL, wait_fn, NULL); if (err != 0) { printf("An error occurred: %d\n", err); return 1; } printf("Waiting for the thread to end...\n"); pthread_join(thread, NULL); printf("Thread ended.\n"); return 0; } 

Expected Output:

Waiting for the thread to end... Done. Thread ended. 

Explanation:

• pthread_create starts a new thread and runs the wait_fn function.
• pthread_join blocks the main thread until the new thread finishes.
• The sleep() call pauses the thread for 2 seconds to simulate work.

Pretty straightforward, right?

🔐 Using Mutexes to Prevent Race Conditions

Multithreading introduces the risk of race conditions, especially when multiple threads access shared resources (e.g., a file or a variable). To prevent this, we use a mutex (short for mutual exclusion).

Here’s an example that shows how to safely increment a shared variable:

#include <pthread.h> #include <unistd.h> #include <stdio.h>  pthread_mutex_t lock; int j; void* do_process(void* arg) { pthread_mutex_lock(&lock); int i = 0; j++; while (i < 5) { printf("%d", j); sleep(1); i++; } printf("...Done\n"); pthread_mutex_unlock(&lock); return NULL; } int main(void) { pthread_t t1, t2; if (pthread_mutex_init(&lock, NULL) != 0) { printf("Mutex initialization failed.\n"); return 1; } j = 0; pthread_create(&t1, NULL, do_process, NULL); pthread_create(&t2, NULL, do_process, NULL); pthread_join(t1, NULL); pthread_join(t2, NULL); pthread_mutex_destroy(&lock); return 0; } 

Output:

11111...Done 22222...Done 

The threads run sequentially because the mutex ensures only one thread can access the shared section at a time.

Tip: Even if you switch the order of pthread_join, the output will be the same because the threads themselves are synchronized by the mutex.

🚦 Semaphores: Flexible Synchronization

Semaphores are another synchronization mechanism, similar to mutexes, but more flexible. Unlike mutexes, semaphores don’t have ownership - any thread can lock or unlock them.

This makes semaphores suitable for managing access to a limited set of resources (like a pool of connections or permits).

We won't dive into full semaphore examples here, but if you're interested, check out the semaphore.h library and functions like sem_init, sem_wait, and sem_post.

✅ Wrapping Up

As you’ve seen, multithreading in C is powerful yet surprisingly approachable. With just a few function calls, you can start writing concurrent programs - but always keep safety in mind with tools like mutexes and semaphores.