In the Linux environment, what operations may cause thread switching?

Linux uses a one-to-one thread model, and the difference between user thread switching and kernel thread switching is very small. At the same time, if you ignore the overhead caused by the user voluntarily giving up the execution rights (yield) of the user thread, you only need to consider the overhead of kernel thread switching. (Recommended learning:linux tutorial)

## 注意 Note that it is just to help the simplification of understanding. In fact, the user thread library does a lot of work in the scheduling and synchronization of user threads, and this cost cannot be ignored.

For example, the JVM explains Thread#yield(): If the underlying OS does not support the semantics of yield, the JVM will let the user thread spin until the end of the time slice, and the thread will be passively switched to achieve a similar effect.

What causes thread switching

Time slice rotation

Thread blocking

Thread actively gives up time slice

Direct overhead

Direct overhead is caused by the thread switching itself, which is inevitable and inevitable.

Switching between user mode and kernel mode

Thread switching can only be completed in kernel mode. If the current user is in user mode, it will inevitably cause a conflict between user mode and kernel mode. switch. ( What are the specific costs of "switching between user mode and kernel mode"???)

Context switching

As mentioned earlier, thread (or process) information needs to be saved with a task_struct. When switching threads, it is necessary to cut out the task_struct of the old thread from the kernel and cut in the new thread to bring about context switching. In addition, it is also necessary to switch registers, program counters, thread stacks (including operation stacks, data stacks), etc.

Thread Scheduling Algorithm

Thread scheduling algorithm needs to manage the status of threads, waiting conditions, etc. If it is scheduled according to priority, it also needs to maintain a priority queue. If thread switching is frequent, this cost cannot be underestimated.

Indirect overhead

Indirect overhead is a side effect of direct overhead and depends on system implementation and user code implementation.

Cache Missing

Switching process requires the execution of new logic. If the address spaces accessed by the two are not similar, cache misses will occur. The specific impact depends on the system implementation and user code implementation. If the system's cache is larger, the impact of cache misses can be reduced; if the address spaces where user threads access data are close to each other, the cache miss rate itself will also be relatively low.

The above is the detailed content of In the Linux environment, what operations may cause thread switching?. For more information, please follow other related articles on the PHP Chinese website!