Threads - Windows Fundamentals

Introduction to Threads

A thread is the basic unit of CPU utilization; it comprises a thread ID, a program counter, a register set, and a stack. A process can have one or more threads. Threads within the same process share common resources such as code sections, data sections, and operating system resources like open files and signals. This shared context allows for efficient communication and data exchange between threads.

Why Use Threads?

Threads offer several advantages:

Responsiveness: In GUI applications, a separate thread can handle user input while another thread performs long-running operations, preventing the UI from freezing.
Resource Sharing: Threads within a process share memory and resources, reducing the overhead compared to creating multiple processes.
Efficiency: Creating and managing threads is typically faster and less resource-intensive than creating and managing processes.
Scalability: Threads can effectively utilize multi-core processors by running tasks in parallel.

Thread States

Threads can exist in several states:

Ready: The thread has the resources it needs to run and is waiting for the CPU.
Running: The thread is currently executing on a CPU.
Blocked/Waiting: The thread cannot run because it is waiting for an event to occur (e.g., I/O completion, mutex release).
Terminated: The thread has finished execution.

Creating and Managing Threads in Windows

The Windows API provides functions for creating and managing threads. The primary function for creating a thread is CreateThread.

The `CreateThread` Function

The CreateThread function creates a new thread within the calling process. Its signature is:


HANDLE CreateThread(
  LPSECURITY_ATTRIBUTES lpThreadAttributes,
  SIZE_T dwStackSize,
  LPTHREAD_START_ROUTINE lpStartAddress,
  LPVOID lpParameter,
  DWORD dwCreationFlags,
  LPDWORD lpThreadId
);

lpStartAddress: A pointer to the application-defined function that the thread will execute.
lpParameter: A pointer to a variable to be passed to the thread function.
dwCreationFlags: Flags that control the thread's state after creation. For example, CREATE_SUSPENDED creates the thread in a suspended state.
lpThreadId: A pointer to a 32-bit variable that receives the thread identifier.

Thread Functions (Entry Point)

A thread's execution begins at a specified function, known as the thread function or entry point. This function typically takes a single LPVOID parameter and returns a DWORD value.


DWORD WINAPI MyThreadFunction(LPVOID lpParam) {
    // Thread logic here
    // ...
    return 0; // Exit code
}

Joining Threads (Waiting for Completion)

To wait for a thread to complete its execution, you can use the WaitForSingleObject function with the thread's handle.


HANDLE hThread = CreateThread(NULL, 0, MyThreadFunction, NULL, 0, NULL);
if (hThread != NULL) {
    WaitForSingleObject(hThread, INFINITE); // Wait indefinitely
    CloseHandle(hThread); // Close the handle when done
}

Synchronization and Race Conditions

When multiple threads access shared data, there's a risk of race conditions, where the outcome depends on the unpredictable timing of thread execution. Synchronization mechanisms are crucial to prevent this:

Mutexes (Mutual Exclusion Objects): Allow only one thread to access a shared resource at a time.
Semaphores: Control access to a resource that has a limited number of instances.
Critical Sections: Lightweight synchronization objects, similar to mutexes, for threads within the same process.
Events: Signal the occurrence of an event to one or more threads.

Example: Using a Critical Section

A critical section ensures that only one thread can execute a specific block of code at a time.


CRITICAL_SECTION cs;
InitializeCriticalSection(&cs);

// Inside a thread function:
EnterCriticalSection(&cs);
// Access shared data safely
LeaveCriticalSection(&cs);

// When done with the critical section:
DeleteCriticalSection(&cs);

Best Practice: Minimize the time spent within critical sections to improve overall application performance and avoid deadlocks.

Thread Priorities

Windows assigns priorities to threads to determine which thread gets CPU time when multiple threads are ready to run. Higher priority threads generally get more CPU time. Thread priorities can be set using functions like SetThreadPriority.

Caution: Improperly managed thread priorities can lead to starvation of lower-priority threads or system instability.

Thread Pools

For applications that frequently create and destroy threads, using thread pools can be more efficient. A thread pool manages a set of worker threads that can execute tasks on demand, avoiding the overhead of creating and terminating threads for each task.

Advanced Concepts

Thread Local Storage (TLS): Allows each thread to have its own copy of a variable, avoiding the need for explicit synchronization.
Fibers: User-mode threads that are managed by the application rather than the operating system, offering finer control but requiring more manual management.
Asynchronous Procedure Calls (APCs): A mechanism to execute a function asynchronously in the context of a specific thread.

Windows Fundamentals