The implementation of threads can be divided into two categories: User-level threads (user-level thread) and kernel thread threads (kernel-level thread). (1) Resource scheduling according to the process, multiple processors, the same process threads can only be reused under the same processor. (1) Thread scheduling does not require the kernel to participate directly, the control is simple
(2) When there are multiple processors, multiple threads of a process can execute simultaneously The system is assigned to several lightweight processes (LWP) in the process, and LWP can obtain the services provided by the kernel through system calls, while the user threads in the process can be reused to correlate to the LWP to obtain the service of the kernel. The user thread cannot use a system call, but when the thread needs system resources, the request is routed to the runtime, which obtains the system resources through the appropriate system calls. These functions reside in user space as an interface between the user thread and the kernel. Functions that include creation, revocation, thread synchronization and communication, and scheduled functions. The runtime system is essentially a collection of functions that are used to manage and control threads. There are two ways in which the intermediate system is implemented, namely the runtime System (Runtimesystem) and the kernel control thread. The user thread runs on top of an intermediate system. (3) The allocation of kernel resources is still allocated according to the process, and the individual user threads can only compete within the process for resources. (2) The kernel is not able to see the user thread. (1) User-level threads exist only in user space. To some extent similar to a process, only the cost of creating and scheduling is smaller than the process. (3) A thread control block (TCB) is set up within the kernel space for each kernel support thread, and the kernel is aware of the existence of the thread and controls it based on that control block. (2) These threads can compete for resources across the system. (1) thread creation, revocation, and switching, all require the kernel to implement directly, that is, the kernel to understand each of the threads as a scheduled entity. A user-level thread is implemented in some systems, and a kernel-level thread is implemented in some systems In multi-threaded operating systems, each system is implemented differently.
0 kommentar(er)
