Introduction

C11 added a standardized threading API so portable C code no longer had to rely only on platform-specific libraries such as POSIX threads or Win32 threads. The main header is threads.h, and it provides threads, mutexes, condition variables, thread-local storage, and one-time initialization. That said, one practical nuance matters immediately: C11 threads are part of the standard, but not every compiler and C library combination implements them equally well.

The core API in threads.h

The central types and functions include:

• 'thrd_t for threads'
• 'thrd_create, thrd_join, and thrd_detach'
• 'mtx_t for mutexes'
• 'cnd_t for condition variables'
• 'tss_t for thread-specific storage'
• 'call_once and once_flag for one-time initialization'

At a high level, the model is similar to other threading libraries: start a thread with a function, synchronize shared state with a mutex, and coordinate waiting with condition variables when needed.

A minimal thread creation example

Here is a simple C11 program that launches one worker thread and waits for it to finish:

1#include <stdio.h>
2#include <threads.h>
3
4int worker(void *arg) {
5    const char *name = arg;
6    printf("hello from %s\n", name);
7    return 0;
8}
9
10int main(void) {
11    thrd_t thread;
12
13    if (thrd_create(&thread, worker, "worker-thread") != thrd_success) {
14        fprintf(stderr, "failed to create thread\n");
15        return 1;
16    }
17
18    thrd_join(thread, NULL);
19    return 0;
20}

The thread function must have the signature int func(void *). That is one of the first differences developers notice when coming from POSIX threads.

Protect shared data with mutexes

Thread creation is the easy part. Correct shared-state access is the harder part. C11 uses mtx_t for mutexes:

1#include <stdio.h>
2#include <threads.h>
3
4static int counter = 0;
5static mtx_t counter_mutex;
6
7int worker(void *arg) {
8    (void)arg;
9
10    for (int i = 0; i < 100000; ++i) {
11        mtx_lock(&counter_mutex);
12        counter++;
13        mtx_unlock(&counter_mutex);
14    }
15
16    return 0;
17}
18
19int main(void) {
20    thrd_t a, b;
21    mtx_init(&counter_mutex, mtx_plain);
22
23    thrd_create(&a, worker, NULL);
24    thrd_create(&b, worker, NULL);
25
26    thrd_join(a, NULL);
27    thrd_join(b, NULL);
28
29    printf("counter = %d\n", counter);
30    mtx_destroy(&counter_mutex);
31    return 0;
32}

Without the mutex, this program has a data race and the final count is not reliable.

Condition variables and one-time initialization

For producer-consumer patterns or waiting for shared state to change, C11 provides condition variables through cnd_t. For one-time global setup, call_once is the standardized solution instead of writing your own fragile initialization flag.

That combination means C11 covers most of the usual building blocks for basic concurrent programs, not just thread creation.

Portability still requires checking your toolchain

One subtle but important fact is that C11 thread support may be absent in some environments. The macro __STDC_NO_THREADS__ can indicate that threads.h is not provided.

So portable C11 threading code often starts with:

#ifdef __STDC_NO_THREADS__
#error "C11 threads are not supported by this toolchain"
#endif

Even when the header exists, build flags and library versions can still affect behavior. That is why real-world C codebases sometimes keep platform-specific fallbacks.

Common Pitfalls

The biggest mistake is assuming C11 threads are universally available everywhere a compiler claims C11 support. Toolchain reality is more uneven than the language standard suggests.

Another issue is focusing on thread creation and forgetting synchronization. Shared writable data without mutexes or atomics is still incorrect, even though the thread API is standardized.

Developers also sometimes confuse C11 atomics and C11 threads. They are related concurrency tools, but they solve different problems.

Finally, do not treat portability as automatic. Standardized APIs help, but build and library support still need verification.

Summary

• C11 introduces a standard threading API through threads.h.
• It includes thread creation, mutexes, condition variables, thread-local storage, and one-time initialization.
• 'thrd_create and thrd_join cover the basic thread lifecycle.'
• Correct synchronization still requires mutexes, atomics, or both.
• Always confirm that your compiler and runtime actually support C11 threads in practice.