Geek Answers Handbook

What is the difference between kernel threads and user threads?

What is the difference between kernel threads and user threads? Is this kernel thread scheduled and running in kernel mode? What methods are used to create kernel threads?

Is it that the user thread is scheduled, executed in user mode? Is this because Kernel is not involved in the execution / scheduling of user threads? When interruptions occur during the execution of a user thread, and who processes it?

Whenever a thread is created, a TCB is created for each. now in the case of user level threads Is this what this TCB is created in the user address space?

In the case of switching between two user-level threads that handle context switching?

There is a concept of multithreaded models:

  • Many to one
  • One to one
  • To many many.

What are these models? How are these models used in practice?

Read a few articles on this topic, but still confused
He wants to clarify the concept.

Thanks in advance, Tazim

+8
multithreading operating-system kernel
source share
4 answers

What is the difference between kernel threads and user threads?

Cell streams are privileged and can access things outside of user mode. Take a look at the “ Ring (computer security) ” on Wikipedia. On Windows, user mode corresponds to Ring 3, and kernel mode corresponds to Ring 0.

What methods are used to create kernel threads?

It is highly dependent on the operating system.

now in case of user level threads. Is it that this TCB is created in the user address space?

TCB records information about the thread that the kernel uses to start this thread, right? Therefore, if it was allocated in user space, the user-mode stream could change or ruin it, which does not seem to be a very good idea. So, don’t you assume that it is created in kernel space?

What are these models? How are these models used in practice?

Wikipedia seems really understandable.

+5
source share

A kernel thread is the thread that the kernel is responsible for planning. This means, among other things, that the kernel can schedule each thread on different processors / cores at the same time.

How to use them, a lot depends on the programming languages ​​and APIs of the streams, but as a simple illustration

void task_a(); void task_b(); int main() { new_thread(task_a); new_thread(task_b); // possibly do something else in the main thread // wait for the threads to complete their work }

In every implementation that I'm familiar with, the kernel can pause them at any time. ("proactive")

User streams, or "User streams", make the program itself responsible for switching between them. There are many ways to do this, and accordingly there are many names for them.

At one end, you have Green Threads; basically trying to do the same thing as kernel threads. Thus, you save all the complexity of programming with real threads.

At the opposite end, you have “Fibers” that must appear before any other fiber is launched. It means

  • The fibers are launched sequentially. There are no concurrent performance improvements.
  • The interaction between the fibers is very well defined. Another code only works with the exact points you get. Other code will not change variables while working on them.
  • Most of the low-complexity issues that programmers face in multithreading, such as cache coherency (looking at MT questions on this site, most people don’t understand this) are not a factor.

As a simple example of fibers, I can think of:

 while(tasks_not_done) { do_part_of_a(); do_part_of_b(); }

where everyone does some work and then comes back when that part is done. Note that they run sequentially in the same "hardware thread", which means that you are not getting performance gains from concurrency. On the other hand, the interactions between them are very clearly defined, so you do not have race conditions. The actual operation of each function may vary. They can also be "user thread objects" from some vector / array.

+1
source share

Essentially, user threads run in the context of the user with appropriate privilege levels, for example. user threads will certainly not have access to the kernel at the memory level / data structures / routines, etc. While kernel threads are executed in the context of the OS kernel, which gives them privileges to execute code that has access to low-level kernel / memory / data structure programs.

0
source share

More articles:


All Articles