多任务编程(多进程与多线程)

什么是多任务编程
多任务编程即一个程序中编写多个任务，在程序运行时让多个任务一起运行，而不是一个一个的顺次执行。
实现多任务编程的方法：

1. 多进程编程（multiprocessing）

2. 多线程编程（threading）

------------------------------> 时间段

顺序执行 任务A 任务B 任务C
并行执行 任务A
任务B
任务C

并发执行 任务A 任务A 任务A
任务B 任务B 任务B
任务C 任务C 任务C

进程状态 （三态）
就绪态
运行态
等待态

         （五态）在三态基础上增加了   新建状态    和  终止状态  

#####################################################################

1. 多进程编程

---

使用模块 multiprocessing
创建流程：（1）将需要新进程执行的事件封装为函数
（2）通过模块的process 类创建进程对象，关联函数
（3）可以通过进程对象设置进程信息及属性
（4）通过进程对象调用start启动进程
（5）通过进程对象调用join 回收进程资源

主要类和函数使用
Process（）
功能：创建进程对象
参数：target 绑定要执行的目标函数
args 元组，用于给target函数位置传参
kwargs 字典，给target函数键值传参

               p.start()
               功能：启动进程
            
               p.join([timeout])          #时间   子进程不影响父进程，父进程也不影响子进程
               功能：阻塞等待回收进程
               参数：超时时间

例 1 ---------------不带参数：

import multiprocessing  
from time import sleep 

#进程进行函数 
def fun():
    print("开始执行")
    sleep(2)
    print("结束")

#创建进程对象
p = multiprocessing.Process(target = fun)

#启动进程 进程诞生，执行fun函数内容
p.start()

#等待执行完后回收
p.join()

例2---------------- 带参数

i

mport multiprocessing  
from time import sleep 

#带有参数的进程函数
def worker(sec,name):
    for i in range(3):
        sleep(sec)
        print("i'm %s" %name)

#位置传参 
#p = Process(target=worker,args =(2,"Levi"))
#关键字传参
#p= Process(target = worker,args=(2,),kwargs={"name":"Baron"})
p.start()
p.join()

---

练习 1. 大文件拆分
将一个文件拆分为两个部分，每个部分分别是文件的一半
即源文件的上下半部分，分别拆到一个新文件里
要求使用两个进程同时进行
提示：按照文件的字节数计算文件大小
os.path.getsize()
思路：获取图片的大小，上下两个部分拆分分别封装为函数

from multiprocessing import Process
import os

size = os.path.getsize("zly.jpg")   #获取文件大小

#复制上部部分
def top():
    fr = open("zly.jpg","rb")
    fw = open("top.jpg","wb")
    n = size//2    #要拷贝n个字节
    while n >=1024:
        fw.write(fr.read(1024))
        n -=1024
    else:
         fw.write(fr.read(n))
    fr.close()
    fw.close()

#复制下部分
def bot():
    fr = open("zly.jpg","rb")
    fw = open("bot.jpg",wb)
    fr.seek(size//2,0)    #文件偏移量到中间
    while True:
        data = fr.read(1024)
        if not data:
            break
        fw.write(data)
    fr.close()
    fw.close()

p = Process(target = top)
p.start()
bot()  #父进程同时执行一个
p.join

---------------------> 结果得到下面图片无法显示

---

进程处理细节

“”""
进程属性设置演示

“”"

from multiprocessing import Process
import time

def fun():
    for i in range(3):
        print(time.ctime())
        time.sleep(2)

#创建进程
p = Process(target = fun)

#该子进程会随父进程退出而退出，在start前 
p.deamon = True

p.start()        #进程启动
print("p.name:",p.name)    #查看子进程名字
print("p.pid:",p.pid)          #进程的标号
print("p.is_alive",p.is_alive)  #是否在生命周期

---

例： 同时创建同时执行

from multiprocessing import Process
from signal import * 

def fun1():
    ...
def fun2():
    ...
def fun3():
    ...

tasks = [fun1,fun2,fun3]
jobs = []

#父进程忽略子进程退出信号，由系统处理
signal(SIGCHLD,SIG_IGN)

#循环创建进程
for th in things:
    p = Process(target = th)
    jobs.append(p)
    p.start()

#统一回收 
for i in jobs:
    i.join() 

说明：处理僵尸进程
导入 : from signal import * ---->创建子进程前插入 signal(SIGCHLD,SIG_IGN)

---

自定义 进程类

"""
自定义进程类

"""

#自定义类
class MyProcess(Process):
    def __init__(self,val):
        self.val = val
        super().__init__()      #加载父类属性 
    
    def fun1(self):      
        print("1",self.val)

    def fun2(self):      
        print("1",self.val)

    #重写run, 将其作为一个新进程的执行内容
    def run(self):
        self.fun1