专栏首页AzMarkPython 学习之进程与线程 「 上 」

Python 学习之进程与线程 「 上 」

阅读本文预计 8 分钟

进程与线程

进程:对于操作系统来说,一个任务就是一个进程(Process),比如打开一个浏览器(任务)就是启动一个浏览器进程。进程是系统中程序执行和资源分配的基本单位,每个进程都有自己的数据段、代码段和堆栈段。

线程:有些进程不止同时干一件事情,比如Word,它可以同时进行打字、拼写检查、打印等事情。在一个进程内部,要同时干多件事情,就需要同时运行多个“子任务”,我们把进程内的这些“子任务”称为线程(Thread),线程是最小的执行单元。

实现多任务原理

现代操作系统比如 Mac OS X,UNIX,Linux,Windows 等,都支持“多任务”。多任务指的是操作系统可以同时运行多个任务,比如同时在聊 QQ,听音乐,码字…

单核CPU实现多任务原理:CPU执行代码都是顺序执行的,操作系统轮流让各个任务交替执行,QQ 执行 2us 秒,切换到听音乐,听音乐执行 2us 秒,再切换到 word,执行 2us 秒…每个任务都是交替执行的,但是由于CPU的调度执行速度实在是太快了,我们感觉就像所有任务都在同时执行一样。

多核CPU实现多任务原理:真正的并行执行多任务只能在多核CPU上实现,但是,由于任务数量远远多于CPU的核心数量,所以,操作系统也会自动把很多任务轮流调度到每个核心上执行。

并行与并发

并发:看上去同时执行,任务数多于核心数 并行:真正同时执行,任务数小于等于核心数

多任务的实现方式:

  1. 多进程模式
  2. 多线程模式
  3. 协程模式
  4. 多进程+多线程模式

单进程(任务)现象

代码块
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.03

4.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.76

5.封装进程对象

一般而言,父进程主要是负责调度子进程的执行,不具体负责某项任务,所以需要进行封装进程对象。将实现各个功能、任务的子线程封装起来,父线程只需负责调用,提高了代码的逻辑与整洁性。

代码块
父进程调用代码
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()))
运行结果

本文分享自微信公众号 - Python梦工厂(AzMark950831)

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2018-08-06

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Python基础知识

    Python技术与生活认知的分享
  • Python 学习之异常

    Python技术与生活认知的分享
  • 听说今天是「520」

    Python技术与生活认知的分享
  • python进程开发

        程序并不能单独运行,只有将程序装载到内存中,系统为它分配资源才能运行,而这种执行的程序就称之为进程。程序和进程的区别就在于:程序是指令的集合,它是进程...

    py3study
  • [Linux] Linux系统(进程管理)

    进程:当我们运行程序时,Linux会为程序创建一个特殊的环境,包含程序运行的所有资源,这个环境就称为进程

    陶士涵
  • 第1章 必须掌握的Linux命令

     命令对象一般是指要处理的文件、目录、用户等资源,而命令参数可以用长格式(完整的选项名称),也可以用短格式(单个字母的缩写),两者分别用--与-作为前缀(示例请...

    mathor
  • 10-1 进程如何工作

    见贤思齊
  • 「Linux 底层原理」理解进程内存布局,掌握程序动态

    简单来讲,进程就是运行中的程序。更进一步,在用户空间中,进程是加载器根据程序头提供的信息将程序加载到内存并运行的实体。

    CSDN技术头条
  • Android多进程的数据库访问问题

    在Android开发中,我们可能会使用单独的进程来做一些事情,比如推送服务,心跳服务等,这些不需要主应用启动,只需要一个独立的进程即可。这时候我们一般都会采用启...

    飞雪无情
  • Python 3 多进程

    进程指的是正在进行的一个过程或者一个任务,而执行这个任务的是CPU。进程与程序的区别,可以理解为程序是我们写的一堆代码,而进程则是CPU执行这堆代码的过...

    用户6184845

扫码关注云+社区

领取腾讯云代金券