python学习第30天

标签：并行   python学习   调度策略   调度   main   RoCE   port   socket通信   自定义类   

一.进程

1.1进程的概念

进程就是正在运行的程序,它是操作系统中,资源分配的最小单位.
资源分配:分配的是cpu和内存等物理资源
进程号是进程的唯一标识

同一个程序执行两次之后是两个进程
进程和进程之间的关系: 数据彼此隔离,通过socket通信

1 . 进程使用的基本语法

process 创建子进程,返回进程的对象p

target 指定要执行的任务

args指定传递的参数,args的类型是元组,多个参数之间用逗号隔开

import os,time
# 当前进程id(子进程)
res = os.getpid()
print(res)

# 当前进程的父进程id
res2 = os.getppid()
print(res2)

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

# windows里面下面这句话必须要加;
if __name__ == "__main__":
    print("3.子进程id>>>>{} , 4.父进程id>>>>{}".format(os.getpid(),os.getppid()))

    # 创建子进程,返回一个进程对象,执行func任务
    p = Process(target = func) # target指定任务
    # 调用子进程
    p.start()

2 . 创建带有参数的进程

def func(n):
    for i in range(1,n+1):
         print("3.子进程id>>>>{} , 4.父进程id>>>>{}".format(os.getpid(),os.getppid()))

if __name__ == "__main__":
    print("1.子进程id>>>>{} , 2.父进程id>>>>{}".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 . 进程之间的数据隔离

主进程和子进程之间是两个独立的空间

count = 100
def func():
    global count
    count += 1
    print("我是子进程count={}".format(count))

if __name__ == "__main__":
    p = Process(target=func)
    p.start()
    time.sleep(1)
    print(count)

4 .多个进程可以异步并发,子父进程之间的关系

# 程序在异步并发任务时,因为cpu调度策略问题,不一定先执行谁或者后执行谁,
整体而言,主进程速度快于子进程,cpu遇到阻塞立刻切换其他任务,等到进程的就绪态在切换回来

# 主程序会默认等待所有的子进程执行结束之后,在关闭程序,释放资源
若不等待,子进程并不方便管理,容易造成僵尸进程,在后台不停的占用系统的资源(cpu和内存),不清楚进程的来源.

def func(args):
    print("3.子进程id>>>>{} , 4.父进程id>>>>{}".format(os.getpid(),os.getppid()) , args)

if __name__ == "__main__":
    for i in range(1,11):
        Process(target=func,args = (i,)).start()

    print("主进程执行结束 ....  ")

5 .join

等待所有子进程全部执行完毕后,主进程任务在继续执行(用来同步子父进程速度)

from multiprocessing import Process
import os

5 .1 join的基本语法

def func():
   print("发送第一封邮件")

if __name__ == "__main__":
   p = Process(target=func)
   p.start()

   p.join()
   print("发送第二封邮件")

5.2 多个子进程配合join使用

def func(index,sex):
   print("发送第%s封邮件"%(index),sex)
if __name__ == "__main__":
   lst = []
   for i in range(10):
      p = Process(target=func,args=(i,1))
      p.start()
      lst.append(p)

   for i in lst:
      print(i)
      i.join()

   print("主进程发最后一封邮件,里面的内容时我发完了")

5.3 使用自定义类的方式创建进程

要求:

1.必须继承Process这个父类

2.所有进程执行任务的逻辑要写在run方法里面

1 . 基本语法

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

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

2 . 带有参数的进程函数

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()))

6 .守护进程

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

默认情况下,主进程会等待所有子进程执行完毕之后,关闭程序,释放资源
守护进程在主进程代码执行结束之后,直接被杀掉

6.1 基本用法

from multiprocessing import Process
def func():
   print("start 当前子进程")
   print("end   当前子进程")

if __name__ == "__main__":
   p = Process(target=func)
   p.daemon = True
   p.start()
   print("主进程执行结束...")

6.2 多个子进程的场景

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("主程序代码结束...")

6.3守护进程的实际用途 :监控报活

import time
def alive():
   while True:
      print("给监控服务器发消息,当前5个服务器功能正常我还活着")
      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.join()
   print("当前服务器状态:统计财务报表功能异常")

1.2并行和并发

并发:一个cpu同一时间不停执行多个程序
并行:多个cpu同一时间不停执行多个程序

1.3cpu的进程调度方法

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

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

1.4进程的三种状态

1.就绪(Ready)状态
	只剩下需要CPU来执行外,其他所有资源都已分配完毕,称为就绪状态
2.执行(Running)状态
	cpu开始执行该进程时称为执行状态
3.阻塞(Blocked)状态
	由于等待某个事件发生而无法执行时,便是阻塞状态,cpu执行其他进程,例如,等待I/O完成input, 申请缓冲区不能满足等等

1.5同步,异步/阻塞,非阻塞

场景在多任务当中
同步:必须等我这件事干完了,你在干,只有一条主线,就是同步
异步:没等我这件事情干完,你就在干了,有两条主线,就是异步
阻塞:比如代码有了input,就是阻塞,必须要输入一个字符串,否则代码不往下执行
非阻塞:没有任何等待,正常代码往下执行.
 
# 同步阻塞  :效率低,cpu利用不充分
# 异步阻塞  :比如socketserver,可以同时连接多个,但是彼此都有recv
# 同步非阻塞:没有类似input的代码,从上到下执行.默认的正常情况代码
# 异步非阻塞:效率是最高的,cpu过度充分,过度发热 液冷

python学习第30天

标签：并行   python学习   调度策略   调度   main   RoCE   port   socket通信   自定义类   

原文地址：https://www.cnblogs.com/yunchao-520/p/13081153.html