Many computing environments support concurrent execution within a single process, allowing them to take advantage of multiple processor cores. Each execution through a program is called a thread.

Multithreading is a natural way to exploit multiple processors, but it has complications. Threads of the same process share the same process state, including all static and dynamic objects, so it's easy for two threads to mistakenly manipulate a complex structure in such a way that it is left in an internally inconsistent state. Avoiding this problem requires concepts such as mutual exclusion and condition variables. Thread-local objects are safe, because such an object is actually a collection of objects, each one being accessible from only one thread. Automatic objects are safe, as long as they are not exposed by storing their addresses in static or dynamic structures.

C11 specifies a threading library in the form of a header <threads.h>. Not all implementations have to include it, so you can test for its availability with an idiom such as:

#if __STDC_VERSION__ > 201112 && __STDC_NO_THREADS__ != 1
#include <threads.h>
#else
#error "Threading unavailable"
#endif

<threads.h> defines thrd_t as a thread identifier. It also defines a number of return codes to indicate the outcome of attempting a thread-related operation. Many functions return thrd_success to indicate a successful operation. thrd_nomem is returned to indicate a lack of memory. thrd_error indicates a failed operation. thrd_busy indicates that a related operation would have blocked under the same conditions. thrd_timedout indicates that an operation timed out.

#include <threads.h>
typedef void (*thrd_start_t)(void *);
int thrd_create(thrd_t *thp, thrd_start_t func, void *arg);
int thrd_detach(thrd_t th);

thrd_create creates a new thread that will execute (*func)(arg). If successful, it assigns the new thread identifier to *thp, and returns thrd_success. If there is insufficient memory to start a new thread, it returns thrd_nomem. If it fails for any other reason, it returns thrd_error.

If the call to (*func)(arg) returns, it behaves as if the thread then calls thrd_exit(0).

thrd_detach tells the environment to deallocate resources for the thread identified by th when it terminates. It returns thrd_success on success, and thrd_error on failure.

#include <threads.h>
thrd_t thrd_current(void);
int thrd_equal(thrd_t a, thrd_t b);

thrd_current returns the identifier of the thread that called it. thrd_equal returns non-zero if the two arguments a and b identify the same thread.

#include <threads.h>
_Noreturn void thrd_exit(int st);
int thrd_join(thrd_t th, int *stp);

If a thread th calls thrd_exit, the thread terminates. If another thread calls thrd_join to join with the thread th, it will block until that thread terminates. The function then returns thrd_success. The argument st becomes the exit status of the thread, and is assigned to *stp for all threads waiting to join it. stp can be NULL, indicating that the calling thread does not require the exit status of th.

thrd_join returns thrd_error if the request to join a thread could not be honoured.

#include <threads.h>
void thrd_yield(void);
int thrd_sleep(const struct timespec *dur,
               struct timespec *rem);

thrd_yield gives other threads an opportunity to run even if the current thread is occupying execution resources, such as a physical processor. thrd_sleep makes the current thread wait for the duration specified by *dur. It then returns zero. If it is interrupted by a signal that is not being ignored with SIG_IGN, it will return prematurely with -1, having assigned the remaining time to *rem if rem is not null. If it fails, it returns some other negative value.