python单核运行,Python线程都在单个核上执行

The GIL is an interpreter-level lock.

This lock prevents execution of

multiple threads at once in the Python

interpreter. Each thread that wants to

run must wait for the GIL to be

released by the other thread, which

means your multi-threaded Python

application is essentially single

threaded, right? Yes. Not exactly.

Sort of.

CPython uses what’s called “operating

system” threads under the covers,

which is to say each time a request to

make a new thread is made, the

interpreter actually calls into the

operating system’s libraries and

kernel to generate a new thread. This

is the same as Java, for example. So

in memory you really do have multiple

threads and normally the operating

system controls which thread is

scheduled to run. On a multiple

processor machine, this means you

could have many threads spread across

multiple processors, all happily

chugging away doing work.

However, while CPython does use

operating system threads (in theory

allowing multiple threads to execute

within the interpreter

simultaneously), the interpreter also

forces the GIL to be acquired by a

thread before it can access the

interpreter and stack and can modify

Python objects in memory all

willy-nilly. The latter point is why

the GIL exists: The GIL prevents

simultaneous access to Python objects

by multiple threads. But this does not

save you (as illustrated by the Bank

example) from being a lock-sensitive

creature; you don’t get a free ride.

The GIL is there to protect the

interpreters memory, not your sanity.