python多线程调用携程_进程，线程，协程与python的实现

进程

进程

进程是程序执行的过程，包括了动态创建、调度和消亡的整个过程，进程是程序资源管理的最小单位。

进程管理的资源包括：CPU(寄存器)，IO, 内存，网络资源等

进程地址空间

当创建一个进程时,操作系统会为该进程分配一个 4GB 大小的虚拟进程地址空间。

操作系统采用虚拟内存技术，把进程虚拟地址空间划分成用户空间和内核空间。每个进程的用户地址空间都是独立的，一般而言是不能互相访问的，但内核空间是每个进程都共享的，所以进程之间要通信必须通过内核。

用户空间按照访问属性一致的地址空间存放在一起的原则，划分成 5个不同的内存区域，总计 3G 的容量:

内存区域

存储内容

栈

局部变量，函数参数，函数的返回值

堆

动态分配的内存

BSS段

未初始化或初值为0的全局变量和静态局部变量

数据段

已初始化且初值非0的全局变量和静态局部变量

代码段

可执行文件的操作指令，可执行程序在内存中的镜像(只读)

在 x86 32 位系统里，Linux 内核地址空间是指虚拟地址从 0xC0000000 开始到 0xFFFFFFFF 为止的高端内存地址空间，总计 1G 的容量， 包括了内核镜像、物理页面表、驱动程序等运行在内核空间 。

进程间通信

当一个进程创建时可以共享程序代码的页，但它们各自有独立的数据拷贝(堆和栈)，因此子进程对内存单元的修改对父进程是不可见的。

进程间的通信方式包括管道、消息队列、共享内存、信号量、信号和Socket。

管道

所谓的管道，就是内核里面的一串缓存。从管道的一端写入的数据，实际上是缓存在内核中的，另一端读取，也就是从内核中读取这段数据。另外，管道传输的数据是无格式的流且大小受限。匿名管道的通信的方式是单向的，如果要双向通信，需要创建两个管道。管道分为匿名管道和命名管道

匿名管道：没有名字标识，是只存在于内存的特殊文件，不存在于文件系统中。匿名管道只能用于存在父子关系的进程间通信。(创建的子进程会复制父进程的文件描述符，这样就做到了两个进程各有两个「 fd[0] 与 fd[1]」，两个进程就可以通过各自的 fd 写入和读取同一个管道文件实现跨进程通信了)它的生命周期随着进程创建而建立，随着进程终止而消失。shell 命令中的 “|”

命名管道：需要在文件系统创建一个类型为 p 的设备文件，不相干的进程从而可以通过这个设备文件进行通信。

管道这种通信方式效率低，不适合进程间频繁地交换数据

消息队列

消息队列是保存在内核中的消息链表，在发送数据时，会分成一个一个独立的数据单元，也就是消息体(数据块)，消息体是用户自定义的数据类型，消息的发送方和接收方要约定好消息体的数据类型，所以每个消息体都是固定大小的存储块，不像管道是无格式的字节流数据。如果进程从消息队列中读取了消息体，内核就会把这个消息体删除。

消息队列不适合比较大数据的传输，因为在内核中每个消息体都有一个最大长度的限制，同时所有队列所包含的全部消息体的总长度也是有上限。

消息队列通信过程中，存在用户态与内核态之间的数据拷贝开销。因为进程写入数据到内核中的消息队列时，会发生从用户态拷贝数据到内核态的过程，同理另一进程读取内核中的消息数据时，会发生从内核态拷贝数据到用户态的过程。

共享内存

现代操作系统，对于内存管理，采用的是虚拟内存技术，也就是每个进程都有自己独立的虚拟内存空间，不同进程的虚拟内存映射到不同的物理内存中。所以，即使进程 A 和 进程 B 的虚拟地址是一样的，其实访问的是不同的物理内存地址，对于数据的增删查改互不影响。

共享内存的机制，就是拿出一块虚拟地址空间来，映射到相同的物理内存中。这样这个进程写入的东西，另外一个进程马上就能看到了，都不需要拷贝来拷贝去，传来传去，大大提高了进程间通信的速度。

信号量

用了共享内存通信方式，带来新的问题，那就是如果多个进程同时修改同一个共享内存，很有可能就冲突了。为了防止多进程竞争共享资源，而造成的数据错乱，信号量使得共享的资源，在任意时刻只能被一个进程访问。

信号量是一个整型的计数器，表示的是资源个数，其值可以通过两个原子操作来控制，分别是 P 操作和 V 操作。主要用于实现进程间的互斥(初始化信号量为1)与同步(初始化信号量为0)，而不是用于缓存进程间通信的数据。

信号

在 Linux 操作系统中， 为了响应各种各样的事件，提供了几十种信号，分别代表不同的意义。我们可以通过 kill -l 命令，查看所有的信号。

运行在 shell 终端的进程，我们可以通过键盘输入某些组合键的时候，给进程发送信号。例如：

Ctrl+C 产生 SIGINT 信号，表示终止该进程；

Ctrl+Z 产生 SIGTSTP 信号，表示停止该进程，但还未结束；

kill -9 1050 ，表示给 PID 为 1050 的进程发送 SIGKILL 信号，用来立即结束该进程

Socket

前面提到的管道、消息队列、共享内存、信号量和信号都是在同一台主机上进行进程间通信，那要想跨网络与不同主机上的进程之间通信，就需要 Socket 通信了。。

Python实现

multiprocessing

from multiprocessing import Process

import os, time

# 子进程要执行的代码

def run_proc(name):

time.sleep(2)

print('Run child process %s (%s)...' % (name, os.getpid()))

if __name__=='__main__':

print('Parent process %s.' % os.getpid())

p = Process(target=run_proc, args=('test',))

print('Child process will start.')

p.start()

p.join()

print('Child process end.')

join所完成的工作就是阻塞当前进程，直到调用join方法的那个进程执行完，再继续执行当前进程

multiprocessing.Pool 进程池

from multiprocessing import Pool

import os, time, random

def long_time_task(name):

print('Run task %s (%s)...' % (name, os.getpid()))

start = time.time()

time.sleep(2)

end = time.time()

print('Task %s runs %0.2f seconds.' % (name, (end - start)))

if __name__=='__main__':

print('Parent process %s.' % os.getpid())

p = Pool(2)

for i in range(3):

p.apply_async(long_time_task, args=(i,))

print('Waiting for all subprocesses done...')

p.close()

p.join()

print('All subprocesses done.')

Parent process 5584.

Waiting for all subprocesses done...

Run task 0 (12836)...

Run task 1 (5916)...

Task 0 runs 2.00 seconds.

Run task 2 (12836)...

Task 1 runs 2.00 seconds.

Task 2 runs 2.00 seconds.

All subprocesses done.

Pool可以提供指定数量的进程供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程。

进程间通信

基于共享内存：进程之间默认是不能共享全局变量的(子进程不能改变主进程中全局变量的值)。如果要共享全局变量需要用(multiprocessing.Value("d",10.0)，数值)(multiprocessing.Array("i",[1,2,3,4,5])，数组)(multiprocessing.Manager().dict()，字典)(multiprocessing.Manager().list()，列表)。

基于管道：包括 multiprocessing.Pipe()，multiprocessing.Queue()。

from multiprocessing import Process, Queue

import os, time

# 写数据进程执行的代码:

def write(q):

print('Process to write: %s' % os.getpid())

for value in ['A', 'B', 'C']:

print('Put %s to queue.' % value)

q.put(value)

time.sleep(2)

# 读数据进程执行的代码:

def read(q):

print('Process to read: %s' % os.getpid())

while True:

value = q.get(True)

print('Get %s from queue.' % value)

if __name__=='__main__':

# 父进程创建Queue，并传给各个子进程：

q = Queue()

pw = Process(target=write, args=(q,))

pr = Process(target=read, args=(q,))

# 启动子进程pw，写入:

pw.start()

# 启动子进程pr，读取:

pr.start()

# 等待pw结束:

pw.join()

# pr进程里是死循环，无法等待其结束，只能强行终止:

pr.terminate()

Process to read: 9504

Process to write: 10672

Put A to queue.

Get A from queue.

Put B to queue.

Get B from queue.

Put C to queue.

Get C from queue.

一个子进程向Queue中写数据，另外一个进程从Queue中取数据，当一个Queue为空的用get取数据会进程会被阻塞。

线程

线程

线程是操作操作系统能够进行运算调度的最小单位。线程被包含在进程之中，是进程中的实际运作单位，一个进程内可以包含多个线程，线程是资源调度的最小单位。

线程的内存模型

每个线程独立的线程上下文：一个唯一的整数线程ID，栈和栈指针，程序计数器，通用目的寄存器和条件码。

和其他线程共享的进程上下文的剩余部分：整个用户虚拟地址空间，包括只读代码段，读/写数据段，堆以及所有的共享库代码和数据区域，也共享所有打开文件的集合。

线程的状态

线程的状态分为：

可运行 (runnable)：线程被创建之后，调用Start()函数就到了这个状态。

运行 (running)：start()函数之后，CPU切换到了这个线程开始执行里面的Run方法就称为运行状态。

阻塞 (blocked)：阻塞状态是指线程因为某种原因放弃了cpu执行权，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu 执行权 转到运行(running)状态。

根据程序分别处于 Running 以及 IO Blocked 两种状态的时间占比，可分为两种：

计算密集型 ，程序执行时大部分时间处于 Running 状态；

IO密集型 ，程序执行时大部分时间处于 IO Blocked 状态；

线程的调度

线程分类：

内核级线程：

内核线程建立和销毁都是由操作系统负责、通过系统调用完成，内核维护进程及线程的上下文信息以及线程切换。

程序一般不会直接使用内核线程，而是使用内核线程的一种高级接口-轻量级进程(Light-weight Process简称LWP ，是一种由内核支持的用户线程，每一个轻量级进程都与一个特定的内核线程关联。)。

优势：内核级线级能参与全局的多核处理器资源分配，充分利用多核 CPU 优势。

局限性：需要系统调度，系统调度代价大，需要在用户态和内核态来回切换；内核进程数量有限。

用户级线程

用户线程的创建、调度、同步和销毁全由用户空间的库函数完成，不需要内核的参与。内核的调度对象是进程本身，内核并不知道用户线程的存在。

优势：性能极强。用户线程的建立，同步，销毁和调度完全在用户态中完成，操作非常快，低消耗，无需切换内核态。

局限性：所有操作都需要自己实现，逻辑极其复杂。 用户线级线程只能参与竞争该进程的处理器资源，不能参与全局处理器资源的竞争。

线程的调度最常用的两种是：

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)。

Python 线程调度实现方式参考了分时调度的思路，只不过将时间片换成字节码 。当一个线程取得 GIL 全局锁并开始执行字节码时，对已执行字节码进行计数。当执行字节码达到一定数量，或者线程主动让出控制(time.sleep(), wait(), blocked IO等)时，线程主动释放 GIL 全局锁。

Python实现

多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响。而多线程中，静态变量，实例变量被线程共享，局部变量不被线程共享：

from threading import Thread

num = 0

def run_thread(name):

global num

num = num + 1

print('{} num: {}'.format(name, num))

if __name__=='__main__':

p1 = Thread(target=run_thread, args=('thread1',))

p2 = Thread(target=run_thread, args=('thread2',))

p1.start()

p2.start()

p1.join()

p2.join()

# thread1 num: 1

# thread2 num: 2

from multiprocessing import Process

num = 0

def run_proc(name):

global num

num = num + 1

print('{} num: {}'.format(name, num))

if __name__=='__main__':

p1 = Process(target=run_proc, args=('process1',))

p2 = Process(target=run_proc, args=('process2',))

p1.start()

p2.start()

p1.join()

p2.join()

# process1 num: 1

# process2 num: 1

线程之间共享数据最大的危险在于多个线程同时改一个变量：

from threading import Thread

num = 0

def change_num(name):

global num

num = num + 1

def run_thread(name):

for i in range(1000000):

change_num(name)

if __name__=='__main__':

p1 = Thread(target=run_thread, args=('thread1',))

p2 = Thread(target=run_thread, args=('thread2',))

p1.start()

p2.start()

p1.join()

p2.join()

print(num)

# 1851956

num的输出值无法预料。原因是对于 num = num + 1 可以分为两步：1)计算num + n，存入该线程的临时变量中； 2)将临时变量的值赋给num。

由于线程之间是进行随机调度的，如果有多个线程同时操作一个对象，如果没有很好地保护该对象，会造成程序结果的不可预期，我们因此也称为“线程不安全”。

可以使用互斥锁(Lock)，同一时刻只允许一个线程执行操作

from threading import Thread, Lock

num = 0

def change_num(name, lock):

global num

lock.acquire()

num = num + 1

lock.release()

def run_thread(name, lock):

for i in range(1000000):

change_num(name, lock)

if __name__=='__main__':

lock = Lock()

p1 = Thread(target=run_thread, args=('thread1', lock))

p2 = Thread(target=run_thread, args=('thread2', lock))

p1.start()

p2.start()

p1.join()

p2.join()

print(num)

# 2000000

由于python GIL全局锁，python多线程并不能提升计算密集型任务的效率。这种情况下可以考虑使用多进程。

from threading import Thread

import time

def change_num(name):

nums = [0] * 100

for num in nums:

for i in range(1000000):

num = num + 1

if __name__=='__main__':

p1 = Thread(target=change_num, args=('thread1',))

start = time.time()

p1.start()

p1.join()

end = time.time()

print('runs %0.2f seconds.' % (end - start))

# runs 21.23 seconds.

from threading import Thread

import time

def change_num(name):

nums = [0] * 100

for num in nums:

for i in range(1000000):

num = num + 1

if __name__=='__main__':

p1 = Thread(target=change_num, args=('thread1',))

p2 = Thread(target=change_num, args=('thread2',))

p3 = Thread(target=change_num, args=('thread2',))

start = time.time()

p1.start()

p2.start()

p3.start()

p1.join()

p2.join()

p3.join()

end = time.time()

print('runs %0.2f seconds.' % (end - start))

# runs 19.49 seconds.

协程

协程

协程，又称微线程。协程的作用，是在执行函数A时，可以随时中断，去执行函数B，然后中断继续执行函数A(可以自由切换)。但这一过程并不是函数调用(没有调用语句)，这一整个过程看似像多线程，然而协程只有一个线程执行。

协程的调度完全由用户控制，协程拥有自己的寄存器上下文和栈，协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作用户空间栈，完全没有内核切换的开销。

协程适用于高并发IO密集型场景

Python实现

python 2.5 中引入 yield/send 表达式用于实现协程

def consumer():

r = ''

while True:

n = yield r

if not n:

return

print('Consuming %s...' % n)

r = '200 OK'

def produce(c):

c.__next__()

n = 0

while n < 3:

n = n + 1

print('Producing %s...' % n)

r = c.send(n)

print('Consumer return: %s' % r)

c.close()

if __name__=='__main__':

c = consumer()

produce(c)

Producing 1...

Consuming 1...

Consumer return: 200 OK

Producing 2...

Consuming 2...

Consumer return: 200 OK

Producing 3...

Consuming 3...

Consumer return: 200 OK

如果一个函数中包含yield关键字，它就不是一个普通函数，而是一个生成器(generator)。调用函数就是创建了一个generator对象。

这个函数，在每次调用next()(python3.x中更名为next())的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

send() 和next() 一样，都能让生成器继续往下走一步(下次遇到yield停)，但send()能传一个值，这个值作为yield表达式整体的结果

整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。

gevent是一个广泛使用的协程框架，它的一个特点是可以用同步的方法写异步应用，不需要写回调函数：

from gevent import monkey; monkey.patch_all()

import gevent

import time

def f(num):

print('start: ' + str(num))

time.sleep(3)

print('end: ' + str(num))

gevent.joinall([

gevent.spawn(f, 1),

gevent.spawn(f, 2),

gevent.spawn(f, 3),

])

start: 1

start: 2

start: 3

end: 1

end: 2

end: 3

我们之所以可以用阻塞的time.sleep()是因为gevent对其进行了monkey_patch，会将所有的socket patch 成非阻塞的，time.sleep()也就变成了gevent.sleep()。

gevent使用多路IO复用对文件描述符的事件监听，当处理一个socket链接时，就创建一个协程Greenlet去处理

当socket遇到阻塞的时候，比如等待数据的返回或者发送，此时gevent会为这个socket的fd在epoll上添加可读或者可写事件回调。然后，通过 get_hub().switch() 切换到主协程，去干其它事情。当该socket可读或者可写时，epoll会调用上述添加的回调函数，从而切换回socket的处理协程，从上次悬挂点接着往下执行。

gevent的monkey patch有个需要注意的地方，它不会patch c扩展模块中的socket。比如说MySQL连接，它仍然是阻塞的。

python 3.5 之后还引入async/await。

1)

import asyncio

async def hw_async():

print('Hello world!')

loop = asyncio.get_event_loop()

loop.run_until_complete(hw_async())

loop.close()

async 是明确将函数声明为协程的关键字。这样的函数执行时会返回一个协程对象。

event loop是协程执行的控制点，如果希望执行协程，就需要用到它们。asyncio启动默认的event loop(asyncio.get_event_loop())， 调度并执行异步任务， 关闭event loop。loop.run_until_complete()这个函数是阻塞执行的， 直到所有的异步函数执行完毕。

2)

import asyncio

import datetime

from threading import currentThread

async def hw_async(num):

print(f"Hello world {num} begin at: {datetime.datetime.now().strftime('%S')},thread:{currentThread().name}")

await asyncio.sleep(3)

print(f"Hello world {num} end at: {datetime.datetime.now().strftime('%S')}")

loop = asyncio.get_event_loop()

tasks = [hw_async(1), hw_async(2),hw_async(3)]

loop.run_until_complete(asyncio.wait(tasks))

loop.close()

Hello world 3 begin at: 53,thread:MainThread

Hello world 1 begin at: 53,thread:MainThread

Hello world 2 begin at: 53,thread:MainThread

Hello world 3 end at: 56

Hello world 1 end at: 56

Hello world 2 end at: 56

从输出可以看出，三个不同的协程函数都是在MainThread线程完成的。并且异步执行。

await语法只能出现在通过async修饰的函数中，否则会报SyntaxError错误。且await后面的对象需要是一个awaitable，有三种主要类型: 协程, 任务 和 Future。

await io操作，此时，当前协程就会被挂起，时间循环转而执行其他协程。但并不是说所有协程里的await都会导致当前携程的挂起，如果跟的是我们定义的携程，则会执行这个携程，如果是asyncio模块制作者定义的固有协程，比如模拟io操作的asyncio.sleep，以及io操作，比如网络io:asyncio.open_connection这些，才会挂起当前携程。

loop.run_until_complete(asyncio.wait(tasks))运行时，会首先将tasks列表里的Coroutines先转换为future

什么时候使用进程，线程和协程

I/O密集型：适合协程

计算密集型：适合多进程 (但进程数量存在限制)

I/O密集型 + 计算密集型：多进程 + 协程