Understanding the C Memory Model and pthreads: The Foundation of Modern Concurrency

Back> 

Understanding the C Memory Model and pthreads: The Foundation of Modern Concurrency

Most high-level languages today, such as Java and C++, offer elegant concurrency constructs like threads, locks, and futures. But underneath these abstractions lies a low-level foundation built upon the operating system and the primitives provided by the C language and its threading library: pthread. Understanding how C manages memory and concurrency not only reveals how things work under the hood, but also makes it easier to grasp subtle issues in C++, Java, or even Python.

---

What Is a Thread? Stack vs Heap and Comparison to Process

In the context of operating systems and memory, a thread is the smallest unit of execution that can be scheduled independently by the OS. Each thread within a process shares the same address space, including the heap and global variables, but has its own stack and registers.

Component	Thread	Process
Address Space	Shared with other threads	Own private address space
Heap	Shared	Private
Global Variables	Shared	Private
Stack	Each thread has its own	Each process has one or more threads
Registers / Program Counter	Independent	Independent
Overhead	Lightweight	Heavyweight
Communication	Easy (shared memory)	Difficult (IPC required)

This distinction is key in understanding concurrency and performance: because threads share heap and global memory, they can communicate faster than processes. However, this also means they need careful synchronization to avoid race conditions and memory corruption.

In C and pthread, the thread’s stack size is typically a few megabytes and can be configured via pthread_attr_setstacksize. The heap, on the other hand, is shared and managed by the process's memory allocator (like malloc or new in C++).

The diagram compares how memory is laid out for separate processes versus multiple threads within a single process. On the left, each process has its own fully isolated memory layout consisting of a stack (used for function calls and local variables), a heap (for dynamic memory allocation), a data segment (for global/static variables like x = 0), and a text/code segment (for program instructions). Each process also maintains its own program counter (PC) and stack pointer (SP), meaning they cannot access each other’s memory without explicit inter-process communication (IPC).

In contrast, the right side illustrates a single process running multiple threads. All threads share the same heap, data, and text/code sections. However, each thread maintains its own stack and its own execution context, including a separate program counter (PC1, PC2, PC3) and stack pointer (SP1, SP2, SP3). This shared-memory model makes thread-based concurrency more efficient than process-based concurrency for communication but also more error-prone if proper synchronization is not used.

Modern high-level languages like Java and Python also follow this model, where each thread has its own stack and shares objects on the heap, requiring memory barriers and visibility guarantees (like Java's volatile) to avoid subtle bugs.

---

The C Memory Model: Basics and Evolution

Historically, the C language did not define a formal memory model. Before C11, the behavior of multi-threaded programs in C was largely platform-dependent and compiler-specific. The C11 standard changed that by introducing a memory model that formalizes how memory operations like reads and writes behave in multi-threaded environments.

The C memory model introduces atomic operations and memory orderings like memory_order_relaxed, acquire, release, and seq_cst. These allow fine-grained control over how threads synchronize and how memory visibility is managed. The model ensures that compilers and processors do not reorder instructions in ways that break the programmer’s expectations.

---

Multithreading in C with pthread

C supports multithreading through the pthread (POSIX Threads) library. It is a thin wrapper around kernel-level threads provided by the operating system, allowing you to create, synchronize, and manage threads directly.

#include <pthread.h>

void* worker(void* arg) {
    // thread function
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, worker, NULL);
    pthread_join(tid, NULL);
    return 0;
}

Pthreads also provide mutexes, condition variables, barriers, and read-write locks—many of which are mirrored in C++ and Java’s concurrency APIs.

---

C Threads Use OS-Level System Calls

The pthread_create function ultimately invokes an OS-level system call such as clone (on Linux) or CreateThread (on Windows). These calls create a new thread of execution within the same process, sharing memory and other resources.

In most modern operating systems, threads are scheduled by the kernel. This means that:

• Thread creation is expensive
• Context switching involves kernel interaction
• Synchronization uses OS primitives like futexes

Languages like Java and C++ may wrap these system calls, but they still rely on the same underlying mechanisms.

---

Sharing Data Between pthreads: Global Variables and Heap Allocation

In C, threads created using pthread_create share global variables and heap-allocated memory by default. However, stack variables are thread-local — they disappear when the thread function exits. If you want to pass data into a thread or keep shared state across threads, you'll typically allocate memory on the heap using malloc() or use global/static variables.

Example: Sharing a Global Counter Among Threads

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

#define NUM_THREADS 4

int global_counter = 0;  // shared among threads
pthread_mutex_t lock;

void* increment(void* arg) {
    for (int i = 0; i < 1000; i++) {
        pthread_mutex_lock(&lock);
        global_counter++;  // safe shared access
        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++) {
        pthread_create(&threads[i], NULL, increment, NULL);
    }

    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("Final counter value: %d\n", global_counter);
    pthread_mutex_destroy(&lock);
    return 0;
}

In this example, all threads increment a shared global variable global_counter. Access is synchronized using a pthread_mutex_t lock to prevent race conditions.

Thread Arguments Can Be Passed by Value Safely (Carefully)

If you're only passing a single value like an integer and can cast it safely to/from void*, you can avoid heap allocation. This works on platforms where pointer sizes and integer sizes match (e.g., 64-bit systems).

// Warning: Only safe if sizeof(void*) >= sizeof(int)
void* worker(void* arg) {
    int id = (int)(intptr_t)arg;
    printf("Thread %d\n", id);
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, worker, (void*)(intptr_t)i);
    }
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
}

We cast the integer i to (void*)(intptr_t) and cast it back in the thread. This avoids heap allocation entirely. But it’s only safe if the platform supports this (most modern ones do).

When Heap Allocation Is Still Needed

If you're passing a pointer to a local variable (like &i), that variable might change before the thread uses it. In that case, you need to allocate memory on the heap to avoid race conditions over stack data.

for (int i = 0; i < NUM_THREADS; i++) {
    int* id = malloc(sizeof(int));
    *id = i;
    pthread_create(&threads[i], NULL, worker, id);
}

This ensures each thread gets a unique and stable copy of the data, avoiding stack reuse bugs.

---

C++, Java, and Python: Built on Top of pthreads

Even though C++ offers abstractions like std::thread and Java offers Thread and ExecutorService, under the hood they use the same pthread or OS-level thread primitives. For example:

• C++11 std::thread maps to pthread_create on POSIX systems
• Java's virtual machine uses native threads and mutexes (via JNI and system calls)
• Python (via CPython) also uses pthreads for its thread implementation, although it's constrained by the GIL

Therefore, understanding how memory visibility, synchronization, and instruction ordering work in C is essential for deeply understanding concurrency in any of these higher-level languages.

---

Memory Visibility and Synchronization

Without proper synchronization, threads may read stale values from shared memory. The C memory model ensures that operations like pthread_mutex_lock() act as memory barriers — they flush writes to shared variables so that other threads see up-to-date values.

pthread_mutex_lock(&lock);
// write shared data
pthread_mutex_unlock(&lock); // release barrier

Similarly, pthread_cond_wait or pthread_barrier_wait help coordinate thread progress and memory consistency. These behaviors are critical when moving to C++ atomic operations or Java's volatile and synchronized keywords.

---

Summary

The pthread library and the C memory model form the backbone of modern concurrency across many languages. When Java uses a synchronized block or C++ uses std::lock_guard, it all ultimately relies on the primitives defined at the C/OS level. By understanding the C concurrency model and the behavior of pthread threads and locks, you gain a deep understanding of how concurrent programming really works—no matter which language you write in.

In short: if you want to master concurrency, study C. Everything else builds on top of it.