`std::thread` and POSIX Threads: A Mapping

The Abstraction Stack: From C++ to the Kernel

std::thread is a C++11 feature that provides a portable, object-oriented interface for managing threads. However, the C++ standard library itself doesn't create threads; it acts as a wrapper around the platform's native threading capabilities.

On a modern Linux system, this creates a clear chain of abstraction:

1. std::thread: The high-level, RAII-capable C++ class you interact with.
2. POSIX Threads (pthreads): A standardized C API for thread management on Unix-like systems. The C++ standard library on Linux (libstdc++) uses this.
3. clone(): A Linux-specific system call that the kernel uses to create new "tasks." The C library's pthread implementation is built on top of this.

This isn't just theory. We can see it in action. The image below shows a debugger's backtrace for a simple C++ program that creates a std::thread.

Let's break down each layer of this stack.

Layer 1: The std::thread Concept

Before we look at the implementation, let's quickly review what a thread is. As you know from your OS studies, a thread is often called a "lightweight process." Threads within the same process run concurrently and share resources like the virtual address space (code, heap, globals), but each thread has its own private instruction pointer, register set, and stack.

This short video provides a good summary of this concept.

The C++ std::thread class provides a modern, portable wrapper around this concept.

Layer 2: The POSIX Threads (Pthreads) API

On Linux, the standard library implementation of std::thread doesn't talk to the kernel directly. Instead, it uses the POSIX threads (Pthreads) library, which is the standard C-level threading API on Unix-like operating systems.

The core function in the Pthreads API is pthread_create(). When you construct a std::thread object, its implementation calls pthread_create() to request a new thread from the underlying system.

The following video discusses this relationship and the role of Pthreads as a portable standard.

So, std::thread is a C++ wrapper around a C API. But how does that C API, Pthreads, work on Linux? This brings us to the kernel level.

Layer 3: The Linux Kernel's "Task" Model and clone()

This is where your OS knowledge and desire for "first principles" truly come into play. A fascinating aspect of the Linux kernel's design is that it does not fundamentally distinguish between processes and threads.

To the kernel, there is only one concept: a task. A task is any schedulable entity, represented by a task_struct data structure in the kernel. What we in user-space call a "process" or a "thread" are both just tasks that have been configured with different levels of resource sharing.

The creation of all new tasks in Linux—whether for a new process (like fork()) or a new thread (pthread_create())—happens through a single, powerful system call: clone().

The behavior of clone() is controlled by a set of flags that specify which resources the new task will share with its parent. This is the key mechanism that differentiates a thread from a process.

To summarize the key points from the article:

When pthread_create() is called, the C library (glibc) invokes the clone() system call with a specific set of flags to create what we know as a thread:

• CLONE_VM: The new task shares the same virtual memory space as the parent. This is the most crucial flag for creating a thread. It's why threads can access the same global variables and heap memory.
• CLONE_FILES: Shares the file descriptor table. This is why a file opened in one thread can be used by another.
• CLONE_SIGHAND: Shares the table of signal handlers.
• CLONE_THREAD: Places the new task in the same "thread group" as the parent.

In contrast, when fork() is called to create a new process, it calls clone() with none of these flags set, resulting in a new task with its own separate resources (using copy-on-write for memory).

Untangling PIDs, TIDs, and Thread Groups

This "unified task" model leads to a common point of confusion regarding Process IDs (PIDs). You may have heard that on Linux, "threads are just processes," which is a statement rooted in the system's history.

Modern Linux (using the Native POSIX Thread Library, or NPTL) handles this elegantly using Thread Groups.

• Thread ID (TID): The kernel assigns a unique ID to every single task on the system. This is the "real" kernel-level process ID.
• Thread Group ID (TGID): All tasks that belong to the same process (i.e., the main thread and all threads it creates) share the same Thread Group ID. The TGID is always equal to the TID of the first thread in the group (the one that called main()).

When you call the getpid() function in your code, it doesn't return the unique TID. It returns the TGID. This is why all threads within a single process appear to have the same PID, conforming to the POSIX standard.

#include <iostream>
#include <thread>
#include <unistd.h>
#include <syscall.h>

void thread_function() {
    std::cout << "Child Thread: \n";
    std::cout << "  getpid() returns: " << getpid() << "\n";
    std::cout << "  syscall(SYS_gettid) returns: " << syscall(SYS_gettid) << "\n";
}

int main() {
    std::thread t(thread_function);

    std::cout << "Main Thread: \n";
    std::cout << "  getpid() returns: " << getpid() << "\n";
    std::cout << "  syscall(SYS_gettid) returns: " << syscall(SYS_gettid) << "\n";

    t.join();
    return 0;
}

Main Thread: 
  getpid() returns: 12345
  syscall(SYS_gettid) returns: 12345
Child Thread: 
  getpid() returns: 12345
  syscall(SYS_gettid) returns: 12346

Conclusion

We've peeled back the layers of abstraction to see exactly how a high-level C++ construct is realized by the operating system. This journey from a C++ object down to a kernel task_struct is a perfect example of the "under the hood" knowledge you're aiming to master.

Key Takeaways:

• std::thread is a portable C++ library class that wraps platform-specific threading APIs.
• On Linux, std::thread is implemented using the Pthreads C library.
• The Pthreads library, in turn, uses the Linux kernel's clone() system call to create new threads.
• The Linux kernel has a unified task model; it does not differentiate between processes and threads internally. The level of resource sharing is determined by flags passed to clone().
• A "thread" is just a task created with flags like CLONE_VM (shared memory) and CLONE_THREAD (shared thread group).
• The user-space getpid() returns the Thread Group ID (TGID), which is shared by all threads in a process. The kernel assigns a unique Thread ID (TID) to each individual task.

What's Next?

Now that we have a solid mental model of what a std::thread is at the system level, our next lesson will focus on the C++ API itself. We will learn how to properly create, launch, and synchronize threads using std::thread objects, covering essential operations like join() and detach(). This will be our first practical step towards building the thread pool project.