# 进程和线程

进程和线程

一家公司就类似一个程序, 进程是公司下属部门,是资源分配的最小单位, 线程则像是部门下属员工
部门之间通信需要建立通道(管道\共享内存)或者公告板(消息队列),
员工之间通信,基本靠吼(全局变量),牛逼的员工也可做到和一个部门(进程)同样的能力

概念

1、多任务编程
	1、意义 : 充分利用计算机的多核资源,同时运行多个任务,提高程序执行的效率
	2、实现方法 : 多进程、多线程
2、概念
	1、并发 : 同时处理多个任务,交替进行,内核在任务间不断切换,达到好像多个任务同时被执行的效果,实际上在每一时刻里,只有一个任务在占用cpu
	2、并行 : 同一时间同时进行多个任务,一起执行,多个任务利用计算机的多核资源同时执行,此时多个任务之间是并行关系
	3.在计算机系统中,并行和并发是同时存在的
进程和程序的定义和区别
	1、进程 : 程序在计算机中的1次运行过程
	2、程序 : 可执行文件,静态的,占用磁盘
	3、区别 : 进程是一个动态的过程,占用计算机资源(CPU、内存),有生命周期
 程序 : 为1个文件,战友外存储器(磁盘)
进程的诞生
	1、用户通过启动程序,或者调用进程创建接口发起请求
	2、操作系统接收用户请求,开始创建进程
	3、操作系统分配计算机资源,确定进程状态,开辟空间等
	4、把进程提供给用户使用

进程

1、cpu时间片
	如果一个进程占用cpu,则称这个进程在CPU事件片上或称这个程序得到了CPU事件片,谁获取到了CPU时间片,谁就可以执行,进程等待
2、PCB(进程控制块) 
	在内存中开辟的一块空间,存放进程的基本信息,也是操作系统调用进程的重要标志.
3、进程ID(PID)
	操作系统为每一个进程分配一个不重复的ID号,该进程在系统中的标识
	查看进程信息 : ps -aux
4、父子进程 : 
	系统中每个进程都有唯一的父进程
	1、查看进程树 : pstree
	2、示例 : 写一个程序,每隔两秒打印一下时间
	3、1个终端运行程序,在另一个终端执行 ps -aux
5.进程状态
	1、三态 : 
	就绪态
		具备执行条件,等待系统分配CPU事件片
	运行态
		占有了cpu时间片
	等待态
		进程暂时祖阻塞,不具备执行条件
	2、五态 :
	新建态:
		创建新进程获取资源的过程
	终止态
		结束进程,释放资源的过程
	3、查看进程状态 : ps -aux 查看STAT列

	4、进程的优先级
		1、作用 : 决定进程的优先权限和占有资源的优先程度
		2、Linux优先级范围(40级) -20~19 越小越高
			默认优先级为0
		3、查看优先级的命令 : top 
		NI 这一列就是优先级 shift -+翻页
		指定优先级 : nice --20 python3 xxxx

进程状态

查看进程状态 : ps -aux 查看STAT列
S : 等待态 (sleep,可中断等待态,阻塞函数)，可中断阻塞(阻塞函数)
D : 等待态(不可中断,系统进程),不可中断阻塞
T : 暂停态(后台程序,暂停执行,但是没有结束)
R : 运行态
Z : 僵尸进程  
< : 较高的优先级
N : 较低的优先级
+ : 前台进程(在终端运行,能够被终端控制的进程)

小技巧

如何后台执行程序
	firefox & - 让程序在后台运行
	如何杀死进程
	kill -9 PID进程号
	如何查找进程PID号
	ps -aux | grep '进程名'
	查看进程信息 : ps -aux
	查看进程树 : pstree

进程的运行特征

1.可使用计算机多核资源
2.计算机分配资源的最小单位(CPU、内存)
3、每个进程空间独立,有自己的资源
4、进程之间的运行互不干扰,相互独立

利用OS模块创建进程

1、方法名 : pid = os.fork()

	功能 : 创建新的进程
	返回值
		1、创建进程失败 : 返回负数
		2、创建进程成功
			1、原进程中返回新进程的PID号
			2、新进程中返回0

2、注意

	用fork()执行结果可能不一致,因为虽然是父子进程,但不存在谦让关系,谁先抢到cpu时间片谁先执行
	各个进程间,资源空间相对独立,不会互相干扰

3.关于fork()

	子进程从fork()下一句开始
	父子进程各自独立运行,运行顺序不一定:
	if 结构和fork()固定搭配
	子进程会复制父进程全部代码和空间,包括fork()之前的资源
	父子进程空间互不影响,各自修改各自空间内容

4.进程函数(os)

	os.getpid()
		获取当前进程的PID号
	os.getppid()
		获取父进程的PID号
	os._exit(status)
		功能 : 退出当前进程
		参数 : status 0 正常 1 异常
		示例 : os._exit(0)
	sys.exit(status)
		功能 :退出当前进程
		参数 : 默认为0 ,可以已传字符串并输出在终端上
		示例 : sys.exit('进程已退出')

5、孤儿进程

	父进程先于子进程退出,此时子进程就是孤儿进程(会被系统进程收养)

6、僵尸进程 : Z

	1、子进程先结束,而且父进程没有处理子进程退出行为,此时子进程为僵尸进程
	2、大量僵尸进程后果: 虽然结束,但是会存留部分进程信息在内存中,耗费系统资源

避免僵尸进程的方法

1、让父进程来处理子进程

	pid,status = os.wait()
	功能 : 分进程中阻塞,等待子进程退出并处理
	返回值 : pid - 已退出的子进程的PID好
        status - 子进程的退出状态(0正常,1异常)

2、二级子进程

让一级子进程先退出,二级子进程变为孤儿进程,被系统进程收养,再让父进程处理一级子进程
的退出,通过将一级子进程直接杀死,使得父进程和二级子进程互无关联,而避免了僵尸进程的出现
if __name__ == '__main__' :
pid = os.fork()
if pid <0:
    print('一级进程创建失败')
elif pid == 0:
    
    p = os.fork()
    if p < 0:
        print('二级进程创建失败')
    elif p == 0:
        print('二级进程创建成功')
        copy2()  #事件2 二级子进程
    else:
        sys.exit('一级子进程退出')
else:
    pid,status = os.wait()
    print('一级子进程处理完毕')
    copy1()  # 事件1 父进程

multiprocessing模块

multiprocessing
一、基本格式
1、导入模块
form multiprocessing import Process
2、将需要执行的进程事件封装为函数
def fun()1… # 不能用input()函数
3、使用Process类生成进程对象,并关联相关函数
if name == ‘main’
p = Process(target = fun1)
4、通过进程对象启动进程(satrt()),自动执行进程函数
p.start()
5、回收进程(避免产生僵尸进程)
p.join()
二、process 类
功能 :
创建进程对象
参数(传给(__init(…))
1.targer = 函数名() : p =process(tager = fun1)
2 . name = ‘进程名’ : 给进程起名字,默认Process -1
3.args = (元祖) : 元祖传参(按照位置给target函数传参)
4. kwargs = {字典} : 字典传参(按照键值对给target传参)
例子:
def fun1(name,age):
…
p=Process(target = fun1,agre(‘郭德纲’,‘45’))
p = process(target = fun1,kwargs =({“name”:“于谦”,“age” : 45})

	p.join([timeout]) : 阻塞等待回收子进程,超时时间,如果超过时间,则解除阻塞
三、Process 类创建进程
	1、同样子进程复制父进程全部空间,父子进程互不影响
	2、join()作用:
		阻塞,处理子进程,等所有子进程结束后执行父进程后面语句
	3、start()后面最好加join(),避免子进程先结束为僵尸进程
	4、父子进程同时做事在start()和join()中间写代码
四、多进程
	1、父进程一般只用来创建子进程和回收子进程,具体事务让子进程来做

父进程 : 负责创建进程、回收进程
子进程们 : 各自执行各自的功能函数
##牺牲了1个进程(父进程)的代价来处理僵尸进程
2、multiprocessing中父进程更方便的创建多个子进程执行更多个事件,父进程往往将事件交由子进程去完成
五、进程中函数的传参
1、元祖传参
args=()
2、字典传参
kwargs = {‘参数名’:要传的值}
6、进程对象 P 属性
1、p.name :进程名称
2、p.pid : 进程pid号
3、p.is_alive : 进程状态
4、p.daemon : 守护进程,默认False,主进程结束,不影响子进程
设置为true ,主进程退出,子进程全部结束
5.daemon不要和join同时使用
守护进程一般为系统后台进程
生命周期很长(开/关机)
7.自定义进程类
1、使用情况 : 使用类将一系列功能进行封装,完成比较复杂的功能

	2、使用流程
		1、集成Process类, Process类中属性和方法就有了
		2、编写自己的__init__()函数
		3、重写run方法,完成功能的逻辑调用(名字不能变)
		4、创建实例化对象
		5、用对象调用一个start()来创建新进程, 自动执行run()方法
		6、用进程对象调用join()方法回收进程
8、进程池
	1、多进程优缺点
		1、优点 : 利用多核资源, 同时执行多任务, 提高效率
		2、缺点 : 进程创建和删除需要消耗较多的系统资源, 

大量进程频繁创建和删除会给系统带来压力
2、进程池
1、产生原因 : 应对大量任务,需要多进程完成, 需要频繁创建和销毁进程的情况
2、原理 : 创建一定量的进程作为进程池, 用来处理事件, 事件处理完成后进程不退出, 而是继续等待处理其他事件, 直到所有待处理事件处理完成后统一销毁, 增加了进程的重复利用率,降低资源消耗.
3、使用流程
1、创建进程池, 放入时长数量的进程
2、将要做的实景封装成函数,放入进程池的等待队列
3、进程池中国的进程不断执行任务,直到全都被执行
4、关闭进程池, 回收进程
4、常用方法
1、类名 : from multiprocessing import pool
2、pool = Pool(porcesses = n) 创建n个进程
功能 : 创建进程池对象
参数 : 指定进程池中进程数量,默认根据系统自动判定(可不写,根据cpu核心数量)
3、想进程池中添加任务的方法
1.poo.apply_async(func,args,kwds)
功能 : 放入要执行的事件函数(异步非阻塞)
解释 : 异步, 交代完任务就去做别的,不会等
参数 : func 事件函数
args 元祖传参
kwds 字典传参
2.poo.apply(func,args,kwds)
功能 : 放入要执行的事件函数(同步阻塞)
解释 : 同步,进程池中只能有1个进程在执行,退出1个,进来1个
参数 : func 事件函数
args 元祖传参
kwds 字典传参
返回值 : 返回函数事件对象(获取到func返回值)
3、poo.map(func,iter)
功能 : 放入要执行的事件函数(同步阻塞)
解释 : 同步,进程池中只能有1个进程在执行,退出1个,进来1个
参数 : func 事件函数
args 元祖传参
kwds 字典传参
返回值 : 返回函数事件对象(获取到func返回值)
获取方法 :
1.robj = pool.apply_async(func,args=(i,))
2.robj.get()
4、pool.close()
功能 : 关闭进程池, 无法再添加新的任务
5、pool.join()
功能 : 阻塞等待回收进程池