第16章 协程#

进程#

进程：一个运行的程序（代码）就是一个进程，没有运行的代码叫程序，进程是系统资源分配的最小单位，进程拥有自己独立的内存空间，所有进程间数据不共享，开销大。

进程： 1、操作系统进行资源分配和调度的基本单位，多个进程之间相互独立 2、稳定性好，如果一个进程崩溃，不影响其他进程，但是进程消耗资源大，开启的进程数量有限制

进程拥有自己独立的堆和栈，既不共享堆，亦不共享栈，进程由操作系统调度。

怎么得出来这结论的？

线程#

线程: cpu调度执行的最小单位，也叫执行路径，不能独立存在，依赖进程存在，一个进程至少有一个线程，叫主线程，而多个线程共享内存（数据共享，共享全局变量),从而极大地提高了程序的运行效率。

线程： 1、CPU进行资源分配和调度的基本单位，线程是进程的一部分，是比进程更小的能独立运行的基本单位，一个进程下的多个线程可以共享该进程的所有资源 2、如果IO操作密集，则可以多线程运行效率高，缺点是如果一个线程崩溃，都会造成进程的崩溃

线程拥有自己独立的栈和共享的堆，共享堆，不共享栈，线程亦由操作系统调度(标准线程是的)。

线程安全#

因为线程间共享进程中的全局变量，所以当其他线程改变了共享的变量时，可能会对本线程产生影响。

所谓线程安全的约束是指一个函数被多个并发线程反复调用时，要一直产生正确的结果。要保证线程安全，主要是通过加锁的方式保证共享变量的正确访问。

换句话说, 线程安全 是在多线程的环境下, 线程安全能够保证多个线程同时执行时程序依旧运行正确, 而且要保证对于共享的数据,可以由多个线程存取,但是同一时刻只能有一个线程进行存取.

既然,多线程环境下必须存在资源的竞争,那么如何才能保证同一时刻只有一个线程对共享资源进行存取?

加锁可以保证存取操作的唯一性, 从而保证同一时刻只有一个线程对共享数据存取.

通常加锁也有2种不同的粒度的锁:

1. fine-grained(所谓的细粒度), 那么程序员需要自行地加,解锁来保证线程安全
2. coarse-grained(所谓的粗粒度), 那么语言层面本身维护着一个全局的锁机制,用来保证线程安全

前一种方式比较典型的是 java, Jython 等, 后一种方式比较典型的是 CPython (即Python). 至于Python中的全局锁机制,也即 GIL (Global Interpreter Lock)

互斥锁#

每个对象都对应于一个可称为’互斥锁‘的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。

同一进程中的多线程之间是共享系统资源的，

多个线程同时对一个对象进行操作，一个线程操作尚未结束，另一线程已经对其进行操作，导致最终结果出现错误，此时需要对被操作对象添加互斥锁，保证每个线程对该对象的操作都得到正确的结果。

阻塞#

阻塞状态指程序未得到所需计算资源时被挂起的状态。程序在等待某个操作完成期间，自身无法继续干别的事情，则称该程序在该操作上是阻塞的。

常见的阻塞形式有：网络 I/O 阻塞、磁盘 I/O 阻塞、用户输入阻塞等。

阻塞是无处不在的，包括 CPU 切换上下文时，所有的进程都无法真正干事情，它们也会被阻塞。 如果是多核 CPU 则正在执行上下文切换操作的核不可被利用。

非阻塞#

程序在等待某操作过程中，自身不被阻塞，可以继续运行干别的事情，则称该程序在该操作上是非阻塞的。

非阻塞并不是在任何程序级别、任何情况下都可以存在的。

仅当程序封装的级别可以囊括独立的子程序单元时，它才可能存在非阻塞状态。

非阻塞的存在是因为阻塞存在，正因为某个操作阻塞导致的耗时与效率低下，我们才要把它变成非阻塞的。

同步#

多个任务之间有先后顺序执行，一个执行完下个才能执行

异步#

多个任务之间没有先后顺序，可以同时执行，有时候一个任务可能要在必要的时候获取另一个同时执行的任务的结果，这个就叫回调

greenlet#

greenlet 是一个轻量级的协程实现，使用的方法简单而清晰。创建 greenlet 实例执行方法，在方法内部可通过 greenlet.switch() 切换至其他 greenlet 实例进行执行

例子：

1
from greenlet import greenlet
2

3

4
def eat():
5
    print("eating start")
6
    g2.switch()
7
    print("eating end")
8
    g2.switch()
9

10

11
def play():
12
    print("playing start")
13
    g1.switch()
14
    print("playing end")
15

16

17
g1 = greenlet(eat)
18
g2 = greenlet(play)
19
g1.switch()

运行结果：

1
eating start
2
playing start
3
eating end
4
playing end

gevent#

gevent 基于 greenlet 库进行了封装，基于 libev 和 libuv 提供了高效的同步API。

对 greenlet 在业务开发中的不便之处，提供了很好的解决方案：

对于 greenlet 实例的管理，不使用树形关系进行组织，隐藏不必要的复杂性

因为协程还是运行在一个OS进程中，所以协程不能跑阻塞任务，否则就要将整个OS进程阻塞住了。

采用 monkey patching 与第三方库协作，将阻塞任务变成非阻塞，也不需要手工通过greenlet.switch() 切换；

例子：

1
import gevent
2

3

4
def foo():
5
    print('Running in foo')
6
    gevent.sleep(0)
7
    print('Explicit context switch to foo again')
8

9

10
def bar():
11
    print('Explicit context to bar')
12
    gevent.sleep(0)
13
    print('Implicit context switch back to bar')
14

15

16
gevent.joinall([
17
    gevent.spawn(foo),
18
    gevent.spawn(bar),
19
])

运行结果：

1
Running in foo
2
Explicit context to bar
3
Explicit context switch to foo again
4
Implicit context switch back to bar

通过这个例子可以看到 两个上下文通过调用 gevent.sleep()来互相切换。

再看一个例子：

1
import gevent
2
import random
3

4

5
def task(pid):
6
    """
7
    Some non-deterministic task
8
    """
9
    gevent.sleep(random.randint(0, 2) * 0.001)
10
    print('Task', pid, 'done')
11

12

13
def synchronous():
14
    for i in range(1, 10):
15
        task(i)
16

17

18
def asynchronous():
19
    threads = [gevent.spawn(task, i) for i in range(10)]
20
    gevent.joinall(threads)
21

22

23
print('Synchronous:')
24
synchronous()
25

26
print('Asynchronous:')
27
asynchronous()

运行结果是：

1
Synchronous:
2
Task 1 done
3
Task 2 done
4
Task 3 done
5
Task 4 done
6
Task 5 done
7
Task 6 done
8
Task 7 done
9
Task 8 done
10
Task 9 done
11
Asynchronous:
12
Task 0 done
13
Task 4 done
14
Task 5 done
15
Task 1 done
16
Task 3 done
17
Task 7 done
18
Task 2 done
19
Task 6 done
20
Task 8 done
21
Task 9 done

在同步的情况下，任务是按顺序执行的，在执行各个任务的时候会阻塞主线程。

而gevent.spawn 的重要功能就是封装了greenlet里面的函数。 初始化的greenlet放在了threads这个list里面，被传递给了 gevent.joinall 这个函数，它会阻塞当前的程序来执行所有的greenlet。

在异步执行的情况下，所有任务的执行顺序是完全随机的。 每一个greenlet的都不会阻塞其他greenlet的执行。