computer thread

The primary reason for introducing threads is to enhance program concurrency and resource utilization, as well as improve system responsiveness and user experience. Below are some common reasons for introducing threads:

Concurrent Execution: Threads allow multiple tasks within a program to execute simultaneously, thereby achieving concurrency. By dividing tasks into multiple threads, multiple tasks can be processed at the same time, increasing program throughput and efficiency. For example, in a network server application, multiple threads can be used to handle requests from multiple clients simultaneously, improving concurrent processing capabilities.
Resource Sharing: Threads can share resources of a process, such as memory space and file descriptors. This avoids each thread having its own independent resource copies, saving memory overhead and improving resource utilization. For example, in a graphical interface application, multiple threads can share the same memory data to achieve concurrent execution of interface updates and background calculations.
Improved System Responsiveness: By placing time-consuming tasks in background threads, the main thread can remain responsive to user input and the interface. This improves system interactivity performance and user experience. For example, in an image processing application, complex image processing algorithms can be executed in background threads to avoid blocking the responsiveness of the main thread.
Simplified Program Design: Using threads allows complex tasks to be divided into smaller sub-tasks, each executed by a single thread. This simplifies program design and maintenance while improving code readability and maintainability. Thread usage enables task modularity and decoupling, enhancing code flexibility and scalability.
Full Utilization of Multi-core Processors: Modern computers typically possess multiple processor cores; using threads allows for the full utilization of parallel computing capabilities provided by multi-core processors. Multiple threads can run simultaneously on different processor cores, increasing program execution speed and performance.

It should be noted that introducing threads also brings certain challenges and risks, such as thread synchronization, resource contention, and deadlocks. Therefore, when designing and implementing multi-threaded programs, it is necessary to plan the number of threads reasonably, use synchronization mechanisms correctly, and conduct thorough testing and debugging to ensure thread correctness and stability.

Concept of Threads

Definition of a Thread

A Thread (线程) is the basic unit of execution in an operating system and represents an execution path within a program. A thread is a part of a process; multiple threads can execute concurrently within the same process while sharing process resources. A single process can contain multiple threads, which can independently execute different tasks but share the same process address space, file descriptors, open files, and other resources.

Threads possess the following characteristics:

Lightweight Execution Units: Compared to processes, thread creation, switching, and destruction incur smaller overheads. Thread switching only requires saving and restoring register context, without needing to switch address spaces.
Shared Process Resources: Threads can share process resources such as memory space, open files, and network connections. This means multiple threads can simultaneously access and manipulate the same data to complete tasks together.
Independent Execution Streams: Each thread has its own program counter, stack, registers, and other execution contexts, enabling it to execute code logic independently.
Communication and Synchronization Between Threads: Threads can communicate and synchronize with each other through mechanisms such as shared memory, semaphores, mutex locks, and condition variables, achieving data sharing and coordinated execution.

The use of threads can enhance program concurrency and resource utilization, allowing programs to execute multiple tasks simultaneously while improving system responsiveness and user experience. However, concurrent thread execution also introduces challenges such as thread synchronization, resource contention, and deadlocks. Therefore, when designing and implementing multi-threaded programs, it is necessary to plan the number of threads reasonably, use synchronization mechanisms correctly, and conduct thorough testing and debugging to ensure thread correctness and stability.

Four Attributes of Threads

Lightweight Entities: Threads are lightweight entities that do not essentially possess system resources; they only own resources indispensable for their operation, such as a single Thread Control Block (TCB), Program Counter (PC), a set of registers, and a stack.
Independent Scheduling and Dispatching Units: Threads are the basic units for independent scheduling and dispatching, and also the basic units capable of independent execution.
Shared Resources: All threads within the same process share all resources owned by that process.
High Degree of Concurrent Execution: The degree of concurrent execution is high; not only can multiple threads within the same process execute concurrently, but also threads belonging to different processes can execute concurrently.

Comparison Between Threads and Traditional Processes

Threads and traditional processes are two important concepts in operating systems, differing in terms of multi-task handling and concurrent execution. Below is a comparison between threads and traditional processes:

Resource Usage: A traditional process is the basic unit for which the operating system allocates resources; each process possesses independent memory space, file descriptors, and other resources. In contrast, a thread is an execution unit within a process, where multiple threads share the resources of the same process, including memory, files, and other system resources. Therefore, thread creation and switching incur smaller overheads compared to process creation and switching.
Concurrency: Traditional processes are mutually independent; they exchange data and synchronize through inter-process communication (IPC). Threads are concurrent execution units within a process; multiple threads can execute simultaneously while sharing process data and state. Communication and synchronization between threads are more convenient and efficient, as they do not require complex IPC mechanisms.
Scheduling and Switching: Traditional process scheduling and switching are managed by the operating system, typically involving overheads such as context switching and memory protection. Thread scheduling and switching are relatively lightweight because threads share the same address space and other resources; switching only requires saving and restoring register context.
Synchronization and Communication: Synchronization and communication between traditional processes require assistance from IPC mechanisms provided by the operating system, such as pipes, message queues, and shared memory. In contrast, synchronization and communication between threads are more direct and simple, achievable through mechanisms like shared memory, mutex locks, and condition variables.
Fault Tolerance: Due to mutual independence between processes, an exception or crash in one process does not affect the execution of other processes. However, since threads share process resources, an error or exception in a single thread may cause the entire process to crash.

In summary, thread creation, switching, and synchronization incur smaller overheads, making them suitable for handling concurrent tasks and improving system responsiveness. Traditional processes are relatively independent, making them suitable for handling independent tasks and ensuring isolation between tasks. In practical applications, the appropriate thread or process model can be selected based on specific requirements and scenarios.

Thread Implementation Principles

Thread implementation can adopt two primary approaches: Kernel-mode Thread Implementation and User-mode Thread Implementation. These approaches differ in aspects such as thread creation, switching, and scheduling.

Kernel-mode Thread Implementation:
Kernel-mode threads are threads directly supported and managed by the operating system kernel. In a kernel-mode thread implementation, thread creation, switching, and scheduling are fully handled by the operating system kernel. Each thread is regarded as an independent scheduling entity with its own kernel stack and context information.

The implementation of kernel-mode threads typically involves the use of system calls. When an application creates a thread, it calls the system call interface provided by the operating system to request new thread resources from the kernel. The kernel allocates an independent kernel stack and Thread Control Block (TCB) for each thread and maintains thread state and scheduling information. Thread switching and scheduling are completed by the operating system kernel.

The advantage of kernel-mode threads is that their switching and scheduling are managed by the operating system kernel, enabling true concurrent execution and multi-core utilization. However, due to the involvement of switching between kernel mode and user mode, thread creation, switching, and synchronization incur larger overheads, affecting performance.
User-mode Thread Implementation:
User-mode threads are implemented within user space; the operating system kernel does not directly perceive or manage them. In a user-mode thread implementation, thread creation, switching, and scheduling are managed by the application's own thread library or runtime library (e.g., the pthread library).

In a user-mode thread implementation, threads created by the application are mapped onto one or more kernel threads, which are responsible for execution within the operating system kernel. The user thread library is responsible for managing thread creation, switching, and scheduling, and provides mechanisms for thread synchronization and communication. The scheduler within the user thread library can perform thread scheduling based on custom policies defined by the application.

The advantage of user-mode threads is that their creation, switching, and synchronization incur smaller overheads because these operations are performed in user space without involving switching between kernel mode and user mode. However, the concurrency of user-mode threads is limited by the implementation of the application's thread library, preventing full utilization of multi-core processor parallel computing capabilities.

It should be noted that kernel-mode threads and user-mode threads are not entirely independent; they can be used in combination. For example, multiple user-mode threads can be mapped onto a single kernel thread to improve concurrency and resource utilization. This hybrid approach achieves a certain balance between user-mode and kernel-mode threads,兼顾 performance and flexibility.