第十三章 进程与线程
程序与进程的概念
++程序++ ：
英文单词为Program，是指一系列有序指令的集合，使用编程语言所编写，用于实现一定的功能。
++进程++ ：
进程则是指启动后的程序，系统会为进程分配内存空间。
函数式创建子进程
在Python中创建进程有两种方式：
第一种使用os模块中的fork函数，但该函数只适用于Unix、Linux和MacOS。
Windows只能使用第二种方式:使用 multiprocessing模块 中的 ++Process类++ 创建进程。
第二种方式创建进程的语法结构：
Process(group = None,target,name,args,kwargs)
参数说明：
- group:表示分组，实际上不使用，值默认为None即可
- target:表示子进程要执行的任务，支持函数名
- name:表示子进程的名称
- args:表示调用函数的位置参数，以元组的形式进行传递
- kwargs:表示调用函数的关键字参数，以字典的形式进行传递
【注】：
target支持函数名，即函数可以作为这个参数传入(函数作为参数时不带小括号，函数调用时才带小括号)。如果target传入的函数有位置参数，就需要用args进行传入；如果target传入的函数有关键字参数，就需要用kwargs进行传入。
++因此group，name可以不写；target必须写；args、kwargs有就写，没有就不写++。
python
# 使用内置模块multiprocessing中的Process类创建进程
from multiprocessing import Process
import os, time
# 函数中的代码是子进程要执行的代码
def test():
print(f'我是子进程，我的PID是:{os.getpid()},我的父进程是:{os.getppid()}')
time.sleep(1)
if __name__ == '__main__':
# main是主进程
print('主进程开始执行')
lst = []
# 创建五个子进程
for i in range(5):
# 创建子进程
p = Process(target=test) # 函数作为参数时不加小括号，函数调用时才加小括号
# 启动子进程
p.start()
# 启动中的进程添加到列表中
lst.append(p)
print('主进程执行结束')
这里会发现子进程还没执行结束时，主进程就已经执行结束了。
原因见下方图示：
那么怎么让所有子进程执行结束之后主进程再执行结束呢？------需要用到 join() 进行阻塞。
python
# 使用内置模块multiprocessing中的Process类创建进程
from multiprocessing import Process
import os, time
# 函数中的代码是子进程要执行的代码
def test():
print(f'我是子进程，我的PID是:{os.getpid()},我的父进程是:{os.getppid()}')
time.sleep(1)
if __name__ == '__main__':
# main是主进程
print('主进程开始执行')
lst = []
# 创建五个子进程
for i in range(5):
# 创建子进程
p = Process(target=test) # 函数作为参数时不加小括号，函数调用时才加小括号
# 启动子进程
p.start()
# 启动中的进程添加到列表中
lst.append(p)
# 当所有子进程执行结束后主进程再执行结束--->使用join()阻塞主进程
# 遍历lst,列表中五个子进程
for item in lst: # item的数据类型是Process类型
# join()-->主进程和子进程在一起执行时，看到join()后主进程便不再执行了，先让子进程执行，子进程执行结束之后再去执行主进程
item.join() # join()是Process对象的方法，作用是阻塞主进程
# 有了join()后主进程要等到所有子进程执行完毕之后，主进程才会执行结束
print('主进程执行结束')
Process类常用的属性和方法
Process类中常用的属性和方法：
| 方法/属性名称 | 功能描述 |
|---|---|
| name | 当前进程实例别名，默认为Process-N |
| pid | 当前进程对象的PID值 |
| is_alive() | 进程是否执行完，没执行完结果为True，否则为False |
| join(timeout) | 等待结束或等待timeout秒 |
| start() | 启动进程 |
| run() | 如果没有指定target参数，则启动进程后，会调用父类(Process)中的run()方法 |
| terminate() | 强制终止进程 |
python
from multiprocessing import Process
import os, time
# 函数中的代码是子进程要执行的代码
# 函数式方式创建子进程
def sub_process(name):
print(f'子进程PID:{os.getpid()},父进程PID是:{os.getppid()}----{name}')
time.sleep(1)
def sub_process2(name):
print(f'子进程PID:{os.getpid()},父进程PID是:{os.getppid()}----{name}')
time.sleep(1)
if __name__ == '__main__':
# main是主进程
print('主进程开始执行')
for i in range(3):
# 创建第一种子进程
# sub_process()有一个位置参数，因此需要用args传入该函数的位置参数，以元组方式
p1 = Process(target=sub_process, args=('lxl',))
# 创建第二种子进程
# sub_process2()有一个位置参数，因此需要用args传入该函数的位置参数，以元组方式
p2 = Process(target=sub_process2, args=(18,))
# 调用start()启动子进程
p1.start()
p2.start()
print(p1.name, '是否处于活跃状态：', p1.is_alive())
print(p2.name, '是否处于活跃状态：', p2.is_alive())
print(p1.name, 'PID是：', p1.pid)
print(p2.name, 'PID是：', p2.pid)
# 阻塞主进程
p1.join() # 主进程要等待p1执行结束
p2.join() # 主进程要等待p2执行结束
print(p1.name, '是否处于活跃状态：', p1.is_alive())
print(p2.name, '是否处于活跃状态：', p2.is_alive())
print('-' * 50)
print('主进程执行结束')
如果将以下两句注释掉：
python
# p1.join() # 主进程要等待p1执行结束
# p2.join() # 主进程要等待p2执行结束则会出现：
具体原因同上面一样。
python
from multiprocessing import Process
import os, time
# 函数中的代码是子进程要执行的代码
# 函数式方式创建子进程
def sub_process(name):
print(f'子进程PID:{os.getpid()},父进程PID是:{os.getppid()}----{name}')
time.sleep(1)
def sub_process2(name):
print(f'子进程PID:{os.getpid()},父进程PID是:{os.getppid()}----{name}')
time.sleep(1)
if __name__ == '__main__':
# main是主进程
print('主进程开始执行')
for i in range(3):
# 创建第一种子进程
# 若没有给定target参数，则不会执行自己编写的函数中的代码，会调用执行Process类中run方法
p1 = Process(target=sub_process, args=('lxl',))
# 创建第二种子进程
p2 = Process(target=sub_process2, args=(18,))
# 调用start()启动子进程
p1.start() # 如果Process类创建对象时没有指定target参数，则会调用Process类中的run方法去执行
p2.start() # 如果Process类创建对象时指定了target参数，start()调用target指定的函数去执行
# 强制终止进程
p1.terminate() # target指定的函数还没有执行，进程就会被终止
p2.terminate()
print('主进程执行结束')
继承式创建子进程
除了使用函数式创建子进程，亦可以使用Python面向对象中的++继承++创建子进程。
使用++继承++创建进程的语法结构：
class 子进程(Process):
pass
即编写一个类，这个类继承Process类，然后重写Process类中的run()方法。
python
from multiprocessing import Process
import os, time
# 自定义一个类
class SubProcess(Process):
# 编写初始化方法
def __init__(self, name):
# 调用父类中的初始化方法
super().__init__()
self.name = name
# 重写父类中的run()方法
def run(self):
print(f'子进程的名称：{self.name},PID:{os.getpid()},父进程的PID:{os.getppid()}')
if __name__ == '__main__':
print('主进程开始执行')
lst = []
for i in range(1, 6):
p1 = SubProcess(f'进程:{i}')
# 启动进程
p1.start() # SubProcess类中没有start()方法，实际上会去调用父类中的start()方法
lst.append(p1)
# 阻塞主进程
for item in lst:
item.join()
print('主进程执行结束')
进程池的使用
当进程数量比较少时，可以使用上面的两种方法Process类或Process的子类创建进程。但如果要创建的进程数量很多，再使用上述的方法创建进程和销毁进程就会耗费大量时间，这时可以使用multiprocessing模块中的 ++Pool类++ 创建进程池。
++进程池的原理++ ：
创建一个进程池，并设置进程池中最大的进程数量。假设进程池中最大的进程数为3，现在有10个任务需要执行，那么进程池一次可以执行3个任务，4次即可完成全部任务的执行。
创建进程池的语法结构：
进程池对象 = Pool(N)
进程池对象的方法：
| 方法名 | 功能描述 |
|---|---|
| apply_async(func,args,kwargs) | 使用非阻塞方式调用函数func |
| apply(func,args,kwargs) | 使用阻塞方式调用函数func |
| close() | 关闭进程池，不再接收新任务 |
| terminate() | 不管任务是否完成，立即终止 |
| join() | 阻塞主进程，必须在terminate()或close()之后使用 |
使用进程池：非阻塞和阻塞方式调用函数func有什么区别：
先来看非阻塞方式：
python
from multiprocessing import Pool
import os, time
# 编写函数(即要执行的任务)
def task(name):
print(f'子进程的PID:{os.getppid()},执行的任务:{name}')
time.sleep(1)
# 使用进程池：非阻塞和阻塞方式调用函数func有什么区别
if __name__ == '__main__':
# 主进程
start = time.time()
print('主进程开始执行')
# 创建进程池
p = Pool(3)
# 创建任务
for i in range(1, 11):
# 以非阻塞方式
# task()有一个位置参数，因此需要用args传入该函数的位置参数，以元组方式
p.apply_async(func=task, args=(i,)) # 函数作为参数不带小括号，调用才带小括号
p.close() # 关闭进程池，不再接收新任务
p.join() # 阻塞父进程，等待所有的子进程执行完毕之后，才会执行父进程中的代码
print('所有的子进程执行完毕，父进程执行结束')
print(time.time() - start)
再来看阻塞方式(只需将 apply_async 方法改成 apply 方法即可)：
python
from multiprocessing import Pool
import os, time
# 编写函数(即要执行的任务)
def task(name):
print(f'子进程的PID:{os.getppid()},执行的任务:{name}')
time.sleep(1)
# 使用进程池：非阻塞和阻塞方式调用函数func有什么区别
if __name__ == '__main__':
# 主进程
start = time.time()
print('主进程开始执行')
# 创建进程池
p = Pool(3)
# 创建任务
for i in range(1, 11):
# 以阻塞方式
# task()有一个位置参数，因此需要用args传入该函数的位置参数，以元组方式
p.apply(func=task, args=(i,)) # 函数作为参数不带小括号，调用才带小括号
p.close() # 关闭进程池，不再接收新任务
p.join() # 阻塞父进程，等待所有的子进程执行完毕之后，才会执行父进程中的代码
print('所有的子进程执行完毕，父进程执行结束')
print(time.time() - start)
并发和并行的概念
++并发++ ：
是指两个或多个事件同一时间间隔发生，多个任务被交替轮换着执行。比如A事件是吃苹果，在吃苹果的过程中有快递员敲门让你收下快递，收快递就是B事件，那么收完快递继续吃没吃完的苹果。这就是并发。
++并行++ ：
指两个或多个事件在同一时刻发生，多个任务在同一时刻在多个处理器上同时执行。比如A事件是泡脚，B事件是打电话，C事件是记录电话内容，这三件事则可以在同一时刻发生，这就是并行。
进程之间数据是否共享
++结论++ ：
进程之间数据是不共享的。
python
from multiprocessing import Process
a = 100
def add():
print('子进程1开始执行')
global a
a += 30
print('a=', a)
print('子进程1执行完毕')
def sub():
print('子进程2开始执行')
global a
a -= 50
print('a=', a)
print('子进程2执行完毕')
if __name__ == '__main__':
# 主进程
print('主进程开始执行')
print('a=', a)
# 创建 加法 的子进程
p1 = Process(target=add)
# 创建 减法 的子进程
p2 = Process(target=sub)
# 启动子进程
p1.start()
p2.start()
# 阻塞主进程
p1.join()
p2.join()
print('主进程执行结束')
print('a=', a)
图示分析：
队列的基本使用
前面说到进程之间的数据是不共享的，但是++可以通过队列来实现进程之间的数据共享++。
进程之间可以通过队列(Queue)进程通信，队列是一种先进先出(First In First Out)的数据结构。
创建队列的语法结构：
队列对象 = Queue(N)
在multiprocessing模块中有一个++Queue类++。
Queue类中的常用方法：
| 方法名称 | 功能描述 |
|---|---|
| qsize() | 获取当前队列包含的消息数量 |
| empty() | 判断队列是否为空，为空结果为True，否则为False |
| full() | 判断队列是否满了，满结果为True，否则为False |
| get(block=True) | 获取队列中的一条消息，然后从队列中移除(出队)，block默认值为True |
| get_nowait() | 相当于get(block=False)，消息队列为空时，抛出异常 |
| put(item,block=True) | 将item消息放入队列，block默认为True |
| put_nowait(item) | 相当于put(item,block=False) |
++注意++ ：
在上面的方法中参数 block 表示 阻塞 的意思。使用get(block=True)【表示进行等待】，当队列为空并不会报错，而且会一直等待，等到队列中有消息时再取出一条消息。使用get_nowait()【相当于get(block=False)表示不进行等待】，当队列为空会报错。使用put(item,block=True)【表示进行等待】，当队列满时并不会报错，而且会一直等待，等到队列中有空位置时再入队。使用put_nowait(item)【put(item,block=False)表示不等待】，当队列满时会报错。
python
from multiprocessing import Queue
if __name__ == '__main__':
# 创建一个队列
q = Queue(3) # 最多可以接收3条信息
print('队列是否为空：', q.empty()) # True
print('队列是否为满：', q.full()) # False
# 向队列中添加消息
q.put('hello')
q.put('world')
print('队列是否为空：', q.empty()) # False
print('队列是否为满：', q.full()) # False
q.put('Python')
print('队列是否为空：', q.empty()) # False
print('队列是否为满：', q.full()) # True
print('队列当中信息的个数：', q.qsize())
# 出队
print(q.get())
print('队列当中信息的个数：', q.qsize())
# 入队
q.put_nowait('html')
# q.put_nowait('sql') # 报错，queue.Full
# q.put('sql') # 不报错，会一直等待，等到队列中有空位置在入队
# 遍历
if not q.empty():
for i in range(q.qsize()):
print(q.get_nowait()) # nowait() 不等待
print('队列是否为空：', q.empty()) # True
print('队列是否为满：', q.full()) # False
print('队列当中信息的个数：', q.qsize())
使用队列实现进程之间的通信
前面说过使用put(item,block=True)【表示进行等待】，当队列满时并不会报错，而且会一直等待，等到队列中有空位置时再入队。
而事实上还有一个参数put(item,block=True,timeout=n)，timeout表示等待n秒后，若队列还没有空位置就抛异常 。
python
from multiprocessing import Queue
if __name__ == '__main__':
# 创建一个队列
q = Queue(3) # 最多可以接收3条信息
# 向队列中添加元素(入队)
q.put('hello')
q.put('world')
q.put('Python')
q.put('html', block=True, timeout=2) # 等待2秒之后，队列还没有空位置就抛异常
进程之间可以使用队列进行通信，实际上就是入队和出队操作，两个进程，一个进程负责入队，另一个进程负责出队即可。
下面例子，使用队列实现进程之间通信，去操作全局变量的值：
python
# 使用队列实现进程之间通信。注意这个队列应该是共享的，写和读用的是同一个队列
from multiprocessing import Queue, Process
import time
a = 100
def writ_msg(q): # q队列
global a
if not q.full():
for i in range(6): # 写6条消息
a -= 10
q.put(a) # 入队
print('a入队时的值：', a)
# 出队
def read_msg(q):
time.sleep(1)
while not q.empty():
print('出队时a的值：', q.get())
if __name__ == '__main__':
print('父进程开始执行')
q = Queue() # 由父进程创建队列，没有指定参数，表示可接收的消息个数没有上限
# 创建两个子进程
p1 = Process(target=writ_msg, args=(q,))
p2 = Process(target=read_msg, args=(q,))
# 启动两个子进程
p1.start()
p2.start()
# 等待写的进程执行结束，再去执行主进程
p1.join()
p2.join()
print('父进程执行结束')
函数式创建线程
一个应用程序内多任务的方式采用的是多进程，一个进程内的多任务方式采用多线程。
++线程++ ：
线程是CPU可调度的最小单位，被包含在进程中，是进程中实际的运作单位。一个进程中可以拥有N多个线程并发执行，而每个线程并行执行不同的任务。
threading模块中有++Thread类++。
函数式创建线程的语法结构(类似进程)：
t = Thread(group,target,name,args,kwargs)
参数说明：
- group:创建线程对象的进程组
- target:创建的线程对象所要执行的目标函数
- name:创建线程对象的名称，默认为"Thread-n"
- args:用元组以位置参数的形式传入target对应函数的参数
- kwargs:用字典以关键字参数的形式传入target对应函数的参数
python
import threading
from threading import Thread
import time
# 编写函数
def test():
for i in range(3):
time.sleep(1)
print(f'线程:{threading.current_thread().name}正在执行{i}')
if __name__ == '__main__':
start = time.time()
print('主线程开始执行')
# 创建两个线程，使用列表生成式
lst = [Thread(target=test) for i in range(2)]
for item in lst: # item的数据类型是Thread类型
# 启动线程
item.start()
# 阻塞主线程
for item in lst:
item.join()
print(f'一共耗时{time.time() - start}')
'''
多个线程并发执行，每个线程并行执行不同的任务。
该程序中共有一个进程(main)，三个线程(main,Thread-1,Thread-2)。
三个线程并行执行的任务是：
主线程负责执行main中的代码
Thread-1线程执行test()三次循环
Thread-2线程执行test()三次循环
三个线程又是并发执行，Thread-1和Thread-2谁先执行不一定。
'''
继承式创建线程
使用Thread子类创建线程的操作步骤(类似进程)：
- 自定义类继承threading模块下的++Thread类++
- 重写run()方法
python
import threading
from threading import Thread
import time
class SubThread(Thread):
# 重写run()方法
def run(self):
for i in range(3):
time.sleep(1)
print(f'线程:{threading.current_thread().name}正在执行{i}')
if __name__ == '__main__':
print('主线程开始执行')
# 继承式创建两个线程，使用列表生成式
lst = [SubThread() for i in range(2)]
for item in lst: # item的数据类型是Thread类型
# 启动线程
item.start()
# 阻塞主线程
for item in lst:
item.join()
print('主线程执行结束')
线程之间数据共享
进程之间的数据不共享，线程之间的数据共享。这是因为线程之间会共享该进程中的资源。
python
from threading import Thread
a = 100 # 全局变量
def add():
print('加线程开始执行')
global a
a += 30
print(f'a的值为：{a}')
print('加的线程执行结束')
def sub():
print('减线程开始执行')
global a
a -= 50
print(f'a的值为：{a}')
print('减的线程执行结束')
if __name__ == '__main__':
print('主线程开始执行')
print(f'全局变量a的值:{a}')
# 线程
add = Thread(target=add)
sub = Thread(target=sub)
# 启动
add.start()
sub.start()
# 阻塞主线程
add.join() # 当加线程执行完毕主线程才能继续执行
sub.join() # 当减线程执行完毕主线程才能继续执行
print(f'主线程执行结束，a的值:{a}')
图示分析：
多个线程共享数据带来的问题以及Lock锁的使用
在上一小节中知道线程共享该进程的资源，所以全局变量a，被这个进程中的所有线程共享。
又因为多个线程是并发执行的，执行顺序无法确定(由CPU调度决定)，所以这就可能造成数据错乱。
下面看一个多线程操作共享数据带来的安全性问题：
python
# 多线程操作共享数据的安全性问题
import threading
from threading import Thread
import time
ticket = 50 # 全局变量。代表50张票
def sale_ticket():
global ticket
# 每个排队窗口(线程)假设有100人
for i in range(100): # 每个线程要执行100次循环
if ticket > 0:
print(f'{threading.current_thread().name}正在出售第{ticket}张票')
ticket -= 1
time.sleep(1)
if __name__ == '__main__':
for i in range(3): # 创建三个线程，代表3个排队窗口
t = Thread(target=sale_ticket)
t.start() # 启动线程
解决这个问题可以采用++Lock锁++。
当线程A去操作共享数据时，对共享数据加一把锁，这时如果线程B想要操作共享数据就只能等待而不可以操作。只有当锁解开时才允许其他线程进行操作。
Lock对象的acquire()、release()方法：
使用Lock锁机制可以解决共享数据带来的安全性问题，那么如何锁，把锁上在什么地方呢?
在使用Lock锁时要把尽量少的、不耗时的代码放到锁中。
threading模块中的++Lock类++。
python
# 使用Lock锁解决多线程操作共享数据的安全性问题
import threading
from threading import Thread, Lock
import time
ticket = 50 # 全局变量。代表50张票
lock_obj = Lock() # 创建锁对象
def sale_ticket():
global ticket
# 每个排队窗口(线程)假设有100人
for i in range(100): # 每个线程要执行100次循环
lock_obj.acquire() # 上锁
if ticket > 0:
print(f'{threading.current_thread().name}正在出售第{ticket}张票')
ticket -= 1
time.sleep(1)
lock_obj.release() # 释放锁
if __name__ == '__main__':
for i in range(3): # 创建三个线程，代表3个排队窗口
t = Thread(target=sale_ticket)
t.start() # 启动线程
使用Lock锁降低了并发度，但可以解决多线程操作共享数据的安全性问题。
生产者与消费者问题
++生产者与消费者模式++ ：
是线程模型中的经典问题，与编程语言无关。当程序中出现了明确的两类任务，一个任务负责生产数据，一个任务负责处理生产的数据时就可以使用该模式。
生产者与消费者问题会出现等待与唤醒问题，如果中间仓库满，生产者等待；如果中间仓库空，消费者等待。
使用Python实现生产者与消费者模式需要用到++Python内置模块queue中的Queue类++。【注意在进程通信中提到的队列是multiprocessing模块中的Queue类】
Python内置模块queue中的Queue类中常用的方法：
| 方法名称 | 功能描述 |
|---|---|
| put(item) | 向队列中放置数据，如果队列为满，则阻塞 |
| get() | 从队列中取走数据，如果队列为空，则阻塞 |
| join() | 如果队列不为空，则等待队列变为空 |
| task_done() | 消费者从队列中取走一项数据，当队列变为空时，唤醒调用join()的线程 |
python
# 生产者与消费者模式
from queue import Queue
from threading import Thread
import time
# 创建一个生产者类
class Producer(Thread):
def __init__(self, name, queue):
Thread.__init__(self, name=name)
self.queue = queue
def run(self):
for i in range(1, 6):
print(f'{self.name}将产品{i}放入队列')
self.queue.put(i)
time.sleep(1)
print('生产者完成了所有数据的存放')
# 创建一个消费者类
class Consumer(Thread):
def __init__(self, name, queue):
Thread.__init__(self, name=name)
self.queue = queue
def run(self):
for i in range(5):
value = self.queue.get()
print(f'消费者线程{self.name}取出了{value}')
time.sleep(1)
print('消费者线程完成了所有数据的取出')
if __name__ == '__main__':
# 创建队列
queue = Queue() # 该队列表示中间仓库。
# 创建生产者线程
p = Producer('Producer', queue)
# 创建消费者线程
c = Consumer('Consumer', queue)
# 启动线程
p.start()
c.start()
# 阻塞主线程
p.join()
c.join()
print('主线程执行结束')