第13章 1 进程和线程

程序和进程的概念 p173

进程是运行态的程序

函数式创建子进程

fork可以用于unix类的操作系统：linux，macos
但是在windows系统中，只能使用Process，详见下

---

第一种创建进程的语法结构：

Process(group=None,target,name,args,kwargs)

参数说明：
1、group：表示分组，实际上不使用，值默认为None即可；可不写
2、target：表示子进程要执行的任务，支持函数名
3、name：表示子进程的名称；可不写
4、args：表示调用函数的位置参数，以元组的形式进行传递；有就写
5、kwargs：表示调用函数的关键字参数，以字典的形式进行传递；有就写

代码实例1：

import multiprocessing
import os
import timedef test():print(f'我是子进程，我的PID是：{os.getpid()}，我的父进程是{os.getppid()}')time.sleep(1)if __name__=='__main__':print('主进程开始执行')lst=[]# 创建五个子进程for i in range(5):# 创建单个子进程p=multiprocessing.Process(target=test) # 返回值类型为：<class 'multiprocessing.context.Process'>print(type(p))# 启动子进程p.start()# 启动中的进程加到列表中lst.append(p)print('主进程执行结束')

上面的运行结果是主进程先结束，子进程在逐个结束
若要求所有子进程中的代码执行结束，主进程在结束，可以使用join()方法，阻塞，见下面：

import multiprocessing
import os
import timedef test():print(f'我是子进程，我的PID是：{os.getpid()}，我的父进程是{os.getppid()}')time.sleep(1)if __name__=='__main__':print('主进程开始执行')lst=[]# 创建五个子进程for i in range(5):# 创建单个子进程p=multiprocessing.Process(target=test) # 返回值类型为：<class 'multiprocessing.context.Process'># 启动子进程p.start()# 启动中的进程加到列表中lst.append(p)for item in lst:item.join()  # 阻塞主进程print('主进程执行结束')

Process类常用的属性和方法1 p175

方法/属性名称	功能描述
name	当前进程实例别名，默认为Process-N
pid	当前进程对象的PID值
is_alive()	进程是否执行完，没执行完结果为True，否则为False
join(timeout)	等待结束或传入了参数就是等待timeout秒
start()	启动进程
run()	若没有指定target参数，则启动进程后，会调用父类中的run方法
terminate()	强制终止进程

代码实例：

import os,multiprocessing,timedef sub_process(name):print(f'子进程pid：{os.getpid()},父进程的pid：{os.getppid()}，入参name={name}')time.sleep(1)def sub_process2(name):print(f'子进程pid：{os.getpid()},父进程的pid：{os.getppid()}，入参name={name}')time.sleep(1)if __name__ == '__main__': # 直接写main# 主进程print('父进程开始执行')for i in range(5):# 创建第一个子进程p1=multiprocessing.Process(target=sub_process,args=('ysj',))# 创建第二个子进程p2=multiprocessing.Process(target=sub_process2,args=(18,))# 调用Process类的start方法启动子进程p1.start()p2.start()# 调用进程对象的类属性print(p1.name,'是否执行完毕：',not p1.is_alive())print(p2.name, '是否执行完毕：', not p2.is_alive())p1.join() # 主程序阻塞等待p1结束p2.join() # 主程序阻塞等待p2结束print('父进程执行结束')

Process类中常用的属性和方法2 p176

代码实例1：

import os,multiprocessing,timeif __name__ == '__main__': # 直接写main# 主进程print('父进程开始执行')for i in range(5):# 创建第一个子进程p1=multiprocessing.Process() # 没有给定taget参数，会调用执行Process类中的run方法# 创建第二个子进程p2=multiprocessing.Process()p1.start() # 调用Process类中的run方法去执行p2.start()print('父进程执行结束')

代码实例2：

import os,multiprocessing,timedef sub_process(name):print(f'子进程pid：{os.getpid()},父进程的pid：{os.getppid()}，入参name={name}')time.sleep(1)def sub_process2(name):print(f'子进程pid：{os.getpid()},父进程的pid：{os.getppid()}，入参name={name}')time.sleep(1)if __name__ == '__main__': # 直接写main# 主进程print('父进程开始执行')for i in range(5):# 创建第一个子进程p1=multiprocessing.Process(target=sub_process,args=('ysj',)) # 没有给定taget参数，会调用执行Process类中的run方法# 创建第二个子进程p2=multiprocessing.Process(target=sub_process2,args=(18,))p1.start()p2.start()# 强制终止进程p1.terminate()p2.terminate()print('父进程执行结束')

继承式创建子进程 p177

第二种创建进程的语法结构：

class 子进程(Process): # 继承Process类，然后去重写run方法pass

代码实例：

import multiprocessing,time,os# 自定义一个类
class SubProcess(multiprocessing.Process): # 继承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() # 没有参数会调用run方法lst.append(p1)# 阻塞主进程，等待子进程执行完毕for item in lst:item.join()print('父进程执行结束')

进程池的使用 p178

若要创建、管理的进程有上百个，创建、销毁线程要消耗大量的时间。进程池可以解决这个问题

进程池的原理：
创建一个进程池，并设置进程池中最大的进程数量。假设进程池中最大的进程数为3，现在有10个任务需要执行，name进程池一次可以执行3个任务，4次即可完成全部任务的执行。

创建进程池的语法结构：

进程池对象=Pool(N)

方法名	功能描述
apply_async(func,args,kwargs)	使用非阻塞方式调用函数func
apply(func,args,kwargs)	使用阻塞方式调用函数func
close()	关闭进程池，不再接受新任务
terminate()	不管任务是否完成，立即终止
join()	阻塞主进程，必须在terminate()或close()之后使用

代码实例：非阻塞运行进程池

import multiprocessing,os,time# 编写任务
def task(name):print(f'子进程的PID：{os.getpid()}，父进程的PID：{os.getppid()}，执行的任务：{name}')time.sleep(1)if __name__ == '__main__':# 主进程start=time.time() # 返回时间戳，单位是秒print(start,':父进程开始执行')# 创建进程池p=multiprocessing.Pool(3)# 创建任务for i in range(10):# 以非阻塞方式p.apply_async(func=task,args=(i,))# 关闭进程池不再接收新任务p.close()# 阻塞主进程等待子进程执行完毕p.join()print(time.time()-start)print('父进程执行结束')

代码实例：阻塞运行进程池

import multiprocessing,os,time# 编写任务
def task(name):print(f'子进程的PID：{os.getpid()}，父进程的PID：{os.getppid()}，执行的任务：{name}')time.sleep(1)if __name__ == '__main__':# 主进程start=time.time() # 返回时间戳，单位是秒print(start,':父进程开始执行')# 创建进程池p=multiprocessing.Pool(3)# 创建任务for i in range(10):# 非阻塞方式p.apply(func=task,args=(i,))# 关闭进程池不再接收新任务p.close()# 阻塞主进程等待子进程执行完毕p.join()print(time.time()-start) # 非阻塞用了4秒多，阻塞方式用了10秒多print('父进程执行结束')

并发和并行 p179

并发：
是指两个或多个事件在 同一时间间隔 发生，多个任务被交替轮换着执行，比如A事件在吃苹果，在吃苹果的过程中有快递员敲门让你收下快递，收快递就是B事件，name收完快递继续吃没吃完的苹果。就是并发。

并行：
指两个或多个事件在同一时刻发生，多个任务在同一时刻在多个处理器上同时执行。比如A事件是泡脚，B事件是打电话，C事件是记录电话内容，这三件事则可以在同一时刻发生，这就是并行。

进程之间数据是否共享 p180

Python当中的并行对应多进程

代码实例：

import multiprocessing,osa=100def add():print('子进程1开始执行')global aa+=30print('a=',a)print('子进程1执行完毕')def sub():print('子进程2开始执行')global aa-=50print('a=',a)print('子进程2执行完毕')if __name__ == '__main__':# 父进程print('父进程开始执行')# 创建加的子进程p1=multiprocessing.Process(target=add)# 创建减的子进程p2=multiprocessing.Process(target=sub())# 启动子进程p1.start()p2.start()# 主进程阻塞，等待子进程执行完成p1.join()p2.join()print('父进程结束执行')

发现结果分别为 130和50，由此发现多进程之间的数据不是共享的，子进程1中有一份a，子进程2中还有另一份a

如何解决进程之间的数据共享，见下一节

队列的基本使用 p180

进程之间可以通过队列（queue）进行通信
队列是一种先进先出的数据结构

---

创建队列的语法结构：

队列对象=Queue(N)

---

方法名称	功能描述
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)

代码实例：

import multiprocessingif __name__ == '__main__':# 创建一个队列q=multiprocessing.Queue(3) # 这个队列最多可以接收3条信息print('队列是否有空？',q.empty())print('队列是否为满？',q.full())print('队列中的消息数？',q.qsize())print('-'*88)# 向队列中添加信息q.put('hello')q.put('world')print('队列是否有空？', q.empty())print('队列是否为满？', q.full())print('队列中的消息数？', q.qsize())print('-'*88)q.put('11111111')print('队列是否有空？', q.empty())print('队列是否为满？', q.full())print('队列中的消息数？', q.qsize())print('-' * 88)print(q.get())print('队列中的消息数？', q.qsize())print(q.get())print(q.get())print('队列中的消息数？', q.qsize())'''
队列的遍历：
for i in range(q.qsize()):q.get_nowait()
'''

使用队列实现进程之间的通信 p182

代码实例1：

import multiprocessingif __name__ == '__main__':q=multiprocessing.Queue(3)# 向队列中添加元素q.put('hello')q.put('world')q.put('python')q.put('html',block=True,timeout=2) # 阻塞等待，最多两秒，若到了两秒会报错返回

代码实例2：

import multiprocessing,timea=100# 入队
def write_msg(q):global a # 要在函数内使用全局变量，一定要先用此方法声明if not q.full():for i in range(6):a-=10q.put(a)print(f'a入队时的值：{a}')# 出队
def read_msg(q):time.sleep(1)while q.qsize()>0:print(f'出队时a的值:{q.get()}')if __name__ == '__main__':print('父进程开始执行')q=multiprocessing.Queue() # 不写参数表示队列接收的消息个数是没有上限的# 创建两个子进程p1=multiprocessing.Process(target=write_msg,args=(q,))p2=multiprocessing.Process(target=read_msg, args=(q,))# 启动两个子进程p1.start()p2.start()# 等待写的进程结束，再去执行主进程p1.join()p2.join()print('父进程执行完毕')

函数式创建线程 p183

线程是cpu可调度的最小单位，被包含在进程中，是进程中实际的运作单位。

一个进程可以拥有N多个线程并发执行，而每个线程并行执行不同的任务。

创建线程的方法有两种：函数式创建线程和继承式创建线程

函数式创建线程的语法结构：

t=Thread(group,target,name,args,kwargs)

参数说明：
1、group：创建线程对象的进程组
2、target：创建线程对象所要执行的目标函数
3、name：创建线程对象的名称，默认为 Thread-n
4、args：用元组以位置参数的形式传入target对应函数的参数
5、kwargs：用字典以关键字参数的形式传入target对应函数的参数

代码实例：

import threading,time# 编写线程执行函数
def test():for i in range(3):time.sleep(1)print(f'线程名：{threading.current_thread().name}，正在执行{i}') # 获取当前的线程对象threading.current_thread()if __name__ == '__main__':start=time.time()print('主线程开始执行')# 线程lst=[threading.Thread(target=test) for i in range(2)]for item in lst: # item的数据类型就是Thread类型# 启动线程item.start()for item in lst:item.join()print('主线程执行完毕')print(f'一共耗时{time.time()-start}秒')# 一共有一个进程，三个线程（一个主线程，两个子线程）

继承式创建线程 p184

使用Thread子类创建线程的操作步骤：
1、自定义类继承threading模块下的Thread类
2、实现run方法

代码实例：

import threading,timeclass SubThread(threading.Thread):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.start()for item in lst:item.join()print('主线程执行完毕')

线程之间数据共享 p185

线程之间的数据可以共享吗？

import threadinga=100def add():print('加线程开始执行')global aa+=30print(f'a的值为{a}')print('加线程执行完成')def sub():print('减线程开始执行')global aa-=50print(f'a的值为{a}')print('减线程执行完成')if __name__ == '__main__':print('主线程开始执行')print(f'全局变量a的值为{a}')add=threading.Thread(target=add)sub=threading.Thread(target=sub)add.start() # a=130sub.start() # a=80add.join()sub.join()print('主线程执行完成')

由此可以得到结论：线程之间是可以共享数据的，进程之间不可以共享数据