❈
阅读本文预计 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 循环结束才可以执行
启动进程执行多任务,各个任务间互不干扰。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)
事实上同时执行的各个任务之间并不是没有关联的,而是需要相互通信和协调,有时,任务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("父进程结束")
以进程池的方式来批量创建多个子进程,体现多任务的并发执行
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("父进程结束")
当拷贝的文件量很少时,单进程的方式比较快,因为多进程需要先创建进程花费时间;当拷贝的文件量很大很多时,多进程的优势就体现出来了。例子中拷贝的是大小为 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.03
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.76
一般而言,父进程主要是负责调度子进程的执行,不具体负责某项任务,所以需要进行封装进程对象。将实现各个功能、任务的子线程封装起来,父线程只需负责调用,提高了代码的逻辑与整洁性。
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()))