day28-2 并发编程I

目录

• 并发编程
  • 串行、并发和并行
  • 阻塞和非阻塞
  • 进程与多进程
  • 进程和程序
  • 进程的创建和销毁
    • 创建
    • 销毁
  • 进程的层次结构
  • PID和PPID
  • python如何使用多进程
    • 创建子进程的方式一
    • 创建子进程的方式二
    • 进程之间内存相互隔离
    • join函数:让主进程等待子进程执行完毕再继续执行
    • 进程对象的常用属性
  • 僵尸进程与孤儿进程

并发编程

串行、并发和并行

串行：程序自上而下的顺序执行，必须把当前任务执行完毕才能执行下一个任务，无论当前任务需要多长时间

并发：多个任务同时执行。但是本质上是不同进程间的切换执行，由于切换速度非常快所以感觉是同时运行。学习并发的目的就是编写可以同时执行多个任务的程序，来提高效率

并行：多个任务真正的同时运行，必须具备多核CPU，有几个核心就能并行几个任务，当任务数量超过核心数还是并发执行

以上三个概念都是用于描述处理任务的方式

阻塞和非阻塞

阻塞：指的是程序遇到IO操作,如input()，无法继续执行代码时的一种状态

非阻塞：指的是程序没有遇到IO操作的一种状态。又分为运行和就绪两种状态

阻塞和非阻塞是用来描述程序的状态，可以用一些手段将阻塞的操作变成非阻塞的操作

进程与多进程

进程：指的是正在运行的程序，是操作系统在调度和进行资源分配的基本单位。当把一个程序从硬盘读入到内存时，进程就产生了

多进程：指的是同一时间有多个程序被装入内存并执行，实现原理就是操作系统调度进程的原理

进程和程序

程序：是一堆代码放在一个文件中，文件通常后缀为exe。在linux系统中没有后缀

进程：是将代码从硬盘读取到内存然后执行产生的。本质上就是一个程序在一个数据集上的一次动态执行过程。一般由程序、数据集（程序运行时产生的数据）、进程控制块三部分组成。

注意：一个程序可以产生多个进程，每一个进程都具备一个PID(进程编号)，且是唯一的

进程的创建和销毁

创建

• 用户的交互式请求，如鼠标双击
• 由一个正在运行的程序调用了开启进程的接口，如subprocess
• 一个批处理作业的开始
• 系统初始化

销毁

• 任务完成——>自愿退出
• 强制结束，在windows系统中用taskkill命令，在linux系统中用kill命令——>非自愿退出
• 程序遇到了异常——>自愿退出
• 严重错误，比如访问了不该访问的内存

进程的层次结构

例如：在QQ中开启了浏览器，那么QQ是父进程，浏览器是子进程

在linux系统中，进程具备父子关系，是一个树状结构，可以相互查找到对方

在windows系统中，进程没有层级关系，父进程可以将子进程的句柄转让

PID和PPID

PID：当前进程的编号，可用os.getpid()获得

PID：是父进程的编号，可用os.getppid()获得

注意：我们在运行py文件时，其实运行的是python解释器

python如何使用多进程

创建子进程的方式一

导入multiprocessing中的Process类，实例化这个类，指定要执行的任务target

import os
from multiprocessing import Process


def task(name):
	# 子进程
    print(f'Son {name} process:', os.getpid())
    print(f'{name} parent process:', os.getppid())

    
# 开启进程的代码必须放在__main__判断下面
if __name__ == '__main__':
    # 实例化一个进程对象，并用函数来指定子进程要做的事情
    p = Process(target=task, args=("nick",)) # args是传入字子进程中的参数
    p.start()  # 开启子进程

    print('Parent process:', os.getpid())
    
-----------------------------------------------------
Parent process: 32692
Son nick process: 17508
nick parent process: 32692

创建子进程的方式二

导入multiprocessing中的Process类，继承这个类，覆盖run方法，将要执行的任务放入run中，开启进程时会自动执行该函数

import os
from multiprocessing import Process


class MyProcess(Process):
    
    # 如果需要对进程对象进行高度自定义，就可以继承它
    # def __init__(self,url,size,name):
    #     super().__init__()
    #     self.url = url
    #     self.size = size
    #     self.name = name
        
    def run(self):
        print('Son process:', os.getpid())
        print('Its parent process:', os.getppid())
        

if __name__ == '__main__':
    p = MyProcess()
    p.start()  # 启动进程时会自动执行run函数

    print('Parent process:', os.getpid())

-----------------------------------------------------
Parent process: 17488
Son process: 34016
Its parent process: 17488

注意：linux与windows系统开启进程的方式不同，linux会将父进程的内存数据完整的复制一份给子进程，windows会导入父进程的代码从头执行一遍来获取需要处理的任务，所以在编写代码时windows系统一定要将开启进程的代码放在main判断中，linux可以不放

进程之间内存相互隔离

import time
from multiprocessing import Process

a = 257


def task():
    global a
    print('Son process:', id(a))


if __name__ == '__main__':
    p = Process(target=task)
    # 进程之间的内存相互隔离，在子进程中修改a的大小不会影响父进程中的a
    print('Parent process old:', id(a))
    p.start()

    time.sleep(10)

    print('Parent process new:', id(a))
    
-----------------------------------------------------
Parent process old: 2117832912592
Son process: 2075741633392
Parent process new: 2117832912592

join函数:让主进程等待子进程执行完毕再继续执行

# 一个子进程
from multiprocessing import Process
import time

def task1(name):
    for i in range(100):
        print("%s run" % name)

if __name__ == '__main__': # args 是给子进程传递的参数 必须是元组
    p1 = Process(target=task1,args=("p1",))
    p1.start()  # 向操作系统发送指令
    p1.join()   # 让主进程 等待子进程执行完毕再继续执行
    p1.join()

    print("over")
-----------------------------------------------------   
# 多个子进程
from multiprocessing import Process
import time
def task1(name):
    for i in range(10000):
        print("%s run" % name)

def task2(name):
    for i in range(100):
        print("%s run" % name)

if __name__ == '__main__': # args 是给子进程传递的参数，必须是元组
    p1 = Process(target=task1,args=("p1",))
    p1.start()  # 向操作系统发送指令

    p2 = Process(target=task2,args=("p2",))
    p2.start()  # 向操作系统发送指令

    p2.join()  # 让主进程等待子进程执行完毕再继续执行
    p1.join()

    # 需要达到的效果是：必须保证两个子进程是并发执行的，并且 over一定是在所有任务执行完毕后执行
    print("over")
-----------------------------------------------------    
# join的使用
from multiprocessing import Process


def task1(name):
    for i in range(10):
        print("%s run" % name)


if __name__ == '__main__':  # args 是给子进程传递的参数 必须是元组

    ps = []
    for i in range(10):
        p = Process(target=task1, args=(i,))
        p.start()
        ps.append(p)

    # 挨个join以下
    for i in ps:
        i.join()

    print("over")

进程对象的常用属性

属性	描述
p.name	进程名字，可以在实例化对象是为进程设置name参数
p.daemon	守护进程
p.exitcode	进程的退出码，在进程的exit()函数中传入的值
p.is_alive()	进程是否存活
p.pid()	进程id（子进程）
p.terminate()	终止进程，与start相同不会立即终止，操作系统需要时间
p.start()	启动进程

僵尸进程与孤儿进程

孤儿进程：当父进程已经结束，而子进程还在运行，子进程就称为孤儿进程。有其存在的必要性，没有不良影响

僵尸进程：当一个进程已将结束了，但是它仍然还有一些数据存在，此时称之为僵尸进程

在linux中有这么一个机制，父进程无论什么时候都可以获取到子进程的一些数据。子进程在任务执行完毕后，确实结束了但是仍然保留一些数据，目的是为了让父进程能够获取这些信息。

在linux中可以调用waitpid来彻底清除子进程的残留信息

在python中已经封装了处理僵尸进程的操作，所以无需关心