实施虚拟线程而不作弊

Question

In the gevent tutorial there's an example that looks like this:

import gevent

def foo():
    print('Running in foo')
    gevent.sleep(0)
    print('Explicit context switch to foo again')

def bar():
    print('Explicit context to bar')
    gevent.sleep(0)
    print('Implicit context switch back to bar')

gevent.joinall([
    gevent.spawn(foo),
    gevent.spawn(bar),
])

and the output is

Running in foo
Explicit context to bar
Explicit context switch to foo again
Implicit context switch back to bar

I've tested it and seen for myself that it works. A friend of mine claims this is run entirely within a single thread. Except that I can't think of any implementation of gevent.sleep(0) which doesn't boil down to some form of "cheating" (ie: Swap the top two stack frames etc.)

Can someone explain how this works? If this were Java (or at least some language where that kind of stack manipulation is forbidden), would this be possible? (again, without using multiple threads).

Answer 1

It indeed runs on only 1 thread. gevent uses greenlets, which are coroutines, not threads. There is only 1 stack at each given time (unless you use multithreading, and then use greenlets in each threads).

In your example above, whenever you call sleep or joinall, the current coroutine (greenlet) actually yields to the hub. Think about the hub as a central dispatcher, responsible to decide which coroutine will run next.

To convince yourself of that, remove the gevent.sleep(0) call, and you'll see that it behaves differently.

Note that unlike threads, the execution is deterministic, so if you run the program twice, it will execute in the exact same order.