Synergetic process

coroutines

coroutines , Also called microthreading , fibers .
Subroutines , Or functions , In all languages, there are hierarchical calls , such as A transfer B,B In the process of execution, it calls C,C Execution complete return ,B Execution complete return , Last A completion of enforcement . So the subroutine is called through the stack , A thread is to execute a subroutine .

It also looks like a subroutine , But during execution , It can be interrupted inside the subroutine , Then execute other subroutines , Come back at the right time and carry out .
Be careful ： Interrupt in a subroutine , To execute other subroutines , It's not a function call , It's kind of similar CPU interrupt .

Change producers and consumers into cooperative processes

import time

def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] Consuming %s...' % n)
        time.sleep(1)
        r = '200 OK'

def produce(c):
    c.next()
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s' % r)
    c.close()

if __name__=='__main__':
    c = consumer()
    produce(c)

Advantages of cooperation

The biggest advantage of cooperative process is its high execution efficiency . Because the switching of subroutines is not thread switching , It's controlled by the program itself , Therefore, there is no overhead of thread switching , Ratio to multithreading , The more threads , The better the performance of the coordination process .
The second advantage of coroutine is that it does not need multi-threaded locking mechanism , Because there's only one thread , Do not write variable conflicts , Control Shared resources without locking in the coroutine , You just have to judge the state , So execution efficiency is much higher than multithreading .