Python 学习之进程与线程 「 上 」
Python 学习之进程与线程 「 上 」
❈
阅读本文预计 8 分钟
❈
进程与线程
进程：对于操作系统来说，一个任务就是一个进程（Process），比如打开一个浏览器（任务）就是启动一个浏览器进程。进程是系统中程序执行和资源分配的基本单位，每个进程都有自己的数据段、代码段和堆栈段。
线程：有些进程不止同时干一件事情，比如Word，它可以同时进行打字、拼写检查、打印等事情。在一个进程内部，要同时干多件事情，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread），线程是最小的执行单元。
实现多任务原理
现代操作系统比如 Mac OS X，UNIX，Linux，Windows 等，都支持“多任务”。多任务指的是操作系统可以同时运行多个任务，比如同时在聊 QQ，听音乐，码字…
单核CPU实现多任务原理：CPU执行代码都是顺序执行的，操作系统轮流让各个任务交替执行，QQ 执行 2us 秒，切换到听音乐，听音乐执行 2us 秒，再切换到 word，执行 2us 秒…每个任务都是交替执行的，但是由于CPU的调度执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。
多核CPU实现多任务原理：真正的并行执行多任务只能在多核CPU上实现，但是，由于任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。
并行与并发
并发：看上去同时执行，任务数多于核心数 并行：真正同时执行，任务数小于等于核心数
多任务的实现方式：
- 多进程模式
- 多线程模式
- 协程模式
- 多进程+多线程模式
单进程（任务）现象
代码块
from time import sleep
def run():
while 1:
print("执行子进程")
sleep(1)
if __name__ == "__main__":
while 1:
print("执行父进程") # 父进程不结束，子进程无法开始
sleep(1)
run() # 不会执行到 run 方法，只有上面的 while 循环结束才可以执行运行结果
多进程（任务）现象
1.任务间互不干扰
启动进程执行多任务，各个任务间互不干扰。multiprocessing 库，跨平台版本的多进程模块，提供了一个 Process 类来代表一个进程对象
代码块
from multiprocessing import Process
from time import sleep
import os
def run1(num):
while 1:
# getpid() 获取当前进程 id 号，getppid() 获取当前进程的父进程 id 号
print("执行子进程-%s" % num, os.getpid(), os.getppid())
sleep(2)
def run2(num):
while 1:
print("执行子进程-%s" % num)
sleep(3)
if __name__ == "__main__":
while 1:
print("启动父（主）进程", os.getpid())
# 创建子进程 target：进程执行的任务, args 为元组类型
p1 =Process(target=run1, args=("01",))
p1.start() # 启动进程
p2 =Process(target=run2, args=("02",))
p2.start() # 启动进程
while True:
print("执行主进程")
sleep(1)运行结果
2. 任务间相互干扰
事实上同时执行的各个任务之间并不是没有关联的，而是需要相互通信和协调，有时，任务1必须暂停等待任务 2 完成后才能继续执行，有时，任务 3 和任务 4 又不能同时执行。所以，多进程和多线程的程序的复杂度要远远高于我们前面写的单进程、单线程的程序。
代码块
from multiprocessing import Process
from time import sleep
def run(num):
print("子进程启动")
sleep(2)
print("子进程结束")
if __name__ == "__main__":
print("父进程启动")
# 创建多个子进程，此处以一个为例
p = Process(target=run, args=("1",))
p.start()
# 未加入 join() 方法时，父进程的结束不影响子进程。为了让父进程等待所有的子进程结束后再继续执行父进程，需要添加一个 join() 方法，通常用于进程间的同步
p.join()
print("父进程结束")运行结果
3.启动大量子进程
以进程池的方式来批量创建多个子进程，体现多任务的并发执行
代码块
from multiprocessing import Pool
import time, os, random
def run(num):
print("子进程 %d 启动 -- %s " % (num, os.getpid()))
start = time.time()
time.sleep(random.choice([1, 2, 3]))
end = time.time()
print("子进程 %d 结束 -- %s -- 耗时 %.2f " % (num, os.getpid(), end-start))
if __name__ == "__main__":
print("父进程启动")
# 以进程池来创建多个进程，Pool 默认大小是 CPU 核心数，表示可以同时执行的进程数量
p = Pool()
for i in range(10):
# 创建进程，放入进程池统一管理
p.apply_async(run, args=(i, ))
# 在调用 join() 之前必须先调用 close() ,调用 close() 之后就不能再继续添加新的进程了
p.close()
# 进程池对象调用 join() ,会等待进程池中所有的子进程结束完再去执行父进程
p.join()
print("父进程结束")运行结果
4.1文件拷贝（单进程）
当拷贝的文件量很少时，单进程的方式比较快，因为多进程需要先创建进程花费时间;当拷贝的文件量很大很多时，多进程的优势就体现出来了。例子中拷贝的是大小为 446 M 的多张图片，多进程花费的时间较少。
代码块
import os,time
# 实现文件的拷贝，此处文件大小为 446 M
def copyFile(rPath, wPath):
fr = open(rPath, "rb")
fw = open(wPath, "wb")
content = fr.read()
fw.write(content)
fr.close()
fw.close()
path = r"C:\Users\Mark\Pictures\pic1\12"
toPath = r"C:\Users\Mark\Pictures\pic1\14"
# 读取 path 下的所有文件
filesList = os.listdir(path)
# 启动 for 循环处理每一个文件
start = time.time()
for fileName in filesList:
copyFile(os.path.join(path, fileName), os.path.join(toPath, fileName))
end = time.time()
print("总耗时：%0.2f " % (end-start)) # 总耗时：19.034.2文件拷贝（多进程）
代码块
import os,time
from multiprocessing import Pool
# 实现文件的拷贝
def copyFile(rPath, wPath):
fr = open(rPath, "rb")
fw = open(wPath, "wb")
content = fr.read()
fw.write(content)
fr.close()
fw.close()
path = r"C:\Users\Mark\Pictures\pic1\12"
toPath = r"C:\Users\Mark\Pictures\pic1\14"
if __name__ == "__main__":
# 读取 path 下的所有文件
filesList = os.listdir(path)
# 启动 for 循环处理每一个文件
start = time.time()
p = Pool()
for fileName in filesList:
p.apply_async(copyFile, args=(os.path.join(path,fileName),os.path.join(toPath,fileName)))
p.close()
p.join()
end = time.time()
print("总耗时：%0.2f " % (end - start)) # 总耗时：15.765.封装进程对象
一般而言，父进程主要是负责调度子进程的执行，不具体负责某项任务，所以需要进行封装进程对象。将实现各个功能、任务的子线程封装起来，父线程只需负责调用，提高了代码的逻辑与整洁性。
代码块
父进程调用代码
from childProcess import childProcess
if __name__ == "__main__":
print("父进程启动")
# 创建子进程
p = childProcess("01")
# 自动调用 p 进程对象的 run 方法
p.start()
p.join()
print("父进程结束")子进程实现功能代码
from multiprocessing import Process
import os,time
class childProcess(Process):
def __init__(self, num):
Process.__init__(self)
self.num = num
def run(self):
print("子进程（ %s -- %s ）启动" % (self.num, os.getpid()))
# 子进程的功能
time.sleep(3)
print("子进程（ %s -- %s ）结束" % (self.num, os.getpid()))运行结果
