Python multithreading model

Question

I have been studying multithreading in python for a while, however I was confused on a few issues-

1. Firstly, are the threads created by the python threading library user level or kernel level threads?

Books say that user level threads must be mapped to kernel threads and the operating system only creates and maintains kernel level threads.

Which thread model will be used in the python threading library? Further, who makes the choice between kernel and user level threads? Is it the operating system or can the programmer have a say?

If the many-to-one model (illustrated in the picture) is used, I think it is not real multithreading, since all the threads map to a single kernel thread.

2. Is there a way to direct the operating system to adhere to a certain threading model in my python program?

3. Can all running threads for a process be shown with their state separately marked as either kernel or user level. Also can the mappings between the two levels (user and kernel) be shown?

Ilonailonka

Answer 1

Usually, you never create 'kernel level threads' directly - everything you do in user space executes in user space, otherwise even a random browser JavaScript would be executing at the kernel level guaranteeing that within seconds the whole internet would go dark.

Thus, in most languages, a threading interface (if supported) is far removed from the actual 'kernel threads' and depending on implementation it will either link to a lower-level threading interface (pthreads for example) or just simulate threading unbeknownst to the user. Going down that chain, pthreads may or may not link to actual 'kernel' threads (it happens to be true on Linux, but on Windows there is another level of separation) but even then, the code executes in the user space - the 'supporting' kernel thread is there to control the scheduling the code runs separately.

When it comes to CPython, its threading interface links to pthreads so, technically, there is a chain from a Python thread all the way down to the kernel threads. However, Python also has the dreaded GIL pretty much guaranteeing that, with some rare exceptions mostly related to I/O, no two threads ever execute at the same time, pretty much making its threads operate in a cooperative multitasking mode. However, since on most systems processes are also backed by kernel threads, you can still utilize them in all their glory by using the multiprocessing interface.

Also, until you have multiple cores/CPUs on your system even kernel threads execute in a cooperative multitasking mode so, technically, kernel threads don't guarantee actual multi-threading as you're describing it.

As for how to list threads and their dependencies, you can use top -H -p <pid> to show the thread tree of a process.

Shopkeeper

thanks man, one question about GIL. GIL said " prevents multiple native threads from executing Python bytecodes at once".Native threads probably is kernel threads.This means ,there is no multithreading in CPython interpreter of python.Presumably it is only non-blocking system on I/O not multithreading. am I wrong ? – Preempt

@FatihAltuntaş - there is some actual parallel execution as not all thread operations are mutex-ed by the GIL, but that's all Python background stuff and the user doesn't get a say in that so, from a users' perspective, there is no parallel processing with Python threading interface. For parallel processing, you have to use the multiprocessing interface, but then you lose all the niceties like shared memory and such (since a big part why GIL exists in the first place is the problem of thread-safety when it comes to memory access). – Shopkeeper

Answer 2

Also, until you have multiple cores/CPUs on your system even kernel threads execute in a cooperative multitasking mode so, technically, kernel threads don't guarantee actual multi-threading as you're describing it.

This is not accurate - even on a single core CPU, kernel threads are not 'cooperative', they are preemptive. The difference is that with preemptive threads, they an all guaranteed time to run. While with cooperative multi-tasking, a single badly written thread could starve all the others of any run-time.

Episcopate