王振2020-6-9笔记

# #### 进程
进程就是正在运行的程序,它是操作系统中,资源分配的最小单位.
资源分配:分配的是cpu和内存等物理资源
进程号是进程的唯一标识
# 并发:一个cpu同一时间不停执行多个程序
# 并行:多个cpu同一时间不停执行多个程序
# 同步:必须等我这件事干完了,你在干,只有一条主线,就是同步
# 异步:没等我这件事情干完,你就在干了,有两条主线,就是异步
# 阻塞:比如代码有了input,就是阻塞,必须要输入一个字符串,否则代码不往下执行
# 非阻塞:没有任何等待,正常代码往下执行.
 
# 同步阻塞  :效率低,cpu利用不充分
# 异步阻塞  :比如socketserver,可以同时连接多个,但是彼此都有recv
# 同步非阻塞:没有类似input的代码,从上到下执行.默认的正常情况代码
# 异步非阻塞:效率是最高的,cpu过度充分,过度发热 液冷

# #### CPU调度方法

先来先服务fcfs(first come first server):先来的先执行
短作业优先算法:分配的cpu多,先把短的算完
时间片轮转算法:每一个任务就执行一个时间片的时间.然后就执行其他的.
多级反馈队列算法

越是时间长的,cpu分配的资源越少,优先级靠后
越是时间短的,cpu分配的资源越多

import os

res = os.getpid()
print(res)

res2 = os.getppid()
print(res2)

from multiprocessing import Process
process 创建子进程,返回进程的对象p,
target指定要执行的任务


def func():
	print("子进程{},父进程{}".format(os.getpid(),os.getppid()))

if __name__ == "__main__":
    print("子进程{},父进程{}".format(os.getpid(), os.getppid()))
    # 创建一个子进程,返回一个进程对象
    p = Process(target = func)
    # 调用子进程
    p.start()

(2)创建带有参数的进程
args 指定传递的参数,args的类型是元组,多个参数之间用,隔开
def func(n):
	for i in range(1,n+1):
		print("子进程{},父进程{}".format(os.getpid(), os.getppid()))

if __name__ == "__main__":
	print("子进程{},父进程{}".format(os.getpid(), os.getppid()))
	n = 5
	p = Process(target = func,args = (n,))
	p.start()
	
	for i in range(1,n+1):
		print("*"*i)

<----------------------------------------------------------------->
(3)进程之间的数据隔离
import time
count = 100
def func():
	global count
	count += 1
	print("我是子进程{}".format(count))
	
if __name__ == "__main__":
	p = Process(target = func)
	p.start()
	time.sleep(1)
	print(count)

<------------------------------------------------------------------->
(4)多个进程可以异步并发
默认程序在异步并发任务时,因为CPU的调度策略问题,不一定先执行谁,后执行谁
整体而言,主进程速度快于子进程,CPU阻塞立马切换到其他任务,等到进程就绪后再回来
主程序会默认等待所有的子进程,都结束后再关闭程序,释放资源


def func(args):
	print("子进程{},父进程{}".format(os.getpid(), os.getppid()),args)
	
if __name__ == "__main__":
	for i in range(1,11):
		Process(target = func,args = (i,)).start()

	print("主程序结束")
	
<------------------------------------------------------------------>
# ### join 等待所有子进程全部执行完毕后,再进行主程序执行,用来同步子父进程
# join 语法

def func():
	print("王振")
if __name__ == "__main__":
	p = Process(target = func)
	p.start()
	p.join()
	print("王振2")
	
# 多个子进程配合join使用
	
def func(index):
	print("王振{}".format(index))
if __name__ == "__main__":
	lst = []
	for i in range(10):
		p = Process(target = func,args = (i,))
		p.start()
		lst.append(p)
	for i in lst:
		print(i)
		i.join()
		
	print("王振2")
	
<------------------------------------------------------------------->
# #### 使用自定义类的方式创建进程(扩展)
自定义类创建进程的要求:
	(1)必须继承Process这个父类
	(2)所有进程执行任务的逻辑要写run方法里面
class MyProcess(Process):
	def run(self):
		print("子进程{},父进程{}".format(os.getpid(), os.getppid()))
		
if __name__ == "__main__":
	p = MyProcess()
	P.start()
	print("2子进程{},2父进程{}".format(os.getpid(), os.getppid()))
	
传参的话,用init方法,在里面手动调用父类的父类的init方法,super()	
class MyProcess(Process):

    def __init__(self,arg):
        # 手动调用一下父类的构造方法(实现进程的创建)
        super().__init__()
        self.arg = arg

    def run(self):
        print("1.子进程id>>>>{} , 2.父进程id>>>>{}".format(os.getpid(),os.getppid()),self.arg)

if __name__ == "__main__":
    p = MyProcess("我是参数")
    p.start()
    print("3.子进程id>>>>{} , 4.父进程id>>>>{}".format(os.getpid(),os.getppid()))

<-------------------------------------------------------------------->
# #### 守护进程
语法:
守护进程守护的是主进程,如果主进程结束了,意味着守护进程寿命终止
进程.daemon = True 设置当前进程为守护进程
必须写在start()调用之前进行设置

默认情况下,主进程会等待所有子进程执行完毕后,关闭程序,释放资源
守护进程在主进程代码执行之后,直接杀掉
from multiprocessing import Process
# ### 基本用法
def func():
    print("start 当前子进程")
    print("end   当前子进程")

if __name__ == "__main__":
    p = Process(target=func)
    p.daemon = True
    p.start()
    print("主进程执行结束 ... ")
	
# ### 多个子进程的场景
import time

def func1():
    count = 1
    while True:
        print("*" * count)
        time.sleep(0.5)
        count += 1
    
def func2():
    print("start func2当前子进程")
    time.sleep(2)
    print("end   func2当前子进程")
    
if __name__ == "__main__":
    p1 = Process(target=func1)
    p2 = Process(target=func2)
    
    # 设置当前进程为守护进程
    p1.daemon = True
    
    p1.start()
    p2.start()
    time.sleep(1)
    
    # 非守护进程,主进程还是会默认等待的.
    print("主程序代码结束....")

<-------------------------------------------------------------------->
# ### 守护进程的实例(监控报活)
import time

# 监控报活
def alive():
    while True:
        print("给监控服务器发消息, 当前5号服务器功能正常 i am ok ~")
        time.sleep(1)

# 当前服务器正常完成的功能
def func():
    time.sleep(5)
    print("当前5号服务器功能,统计财务报表~")

if __name__ == "__main__":
    p1 = Process(target=func)
    p2 = Process(target=alive)
    p2.daemon = True
    
    p1.start()
    p2.start()
    
    # 等待p1子进程执行结束之后,下面的主程序的代码才会放行;
    p1.join()
    
    print("当前服务器状态:统计财务报表功能异常.....")