zoukankan      html  css  js  c++  java
  • python学习第30天

    一.进程

    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过度充分,过度发热 液冷
    
  • 相关阅读:
    MYsql 主从复制
    linux下修改apache,nginx服务端口号
    nginx的安装
    oracle启动流程
    openfire源码编译后部署到linux
    openfire重新配置数据库oracle、mysql
    spark安装和登陆配置
    Linux下安装Openfire 4.2.1
    mac toad下建表问题
    linux 下使用exp/imp 或者expdp/impdp导出导入oracle数据表数据
  • 原文地址:https://www.cnblogs.com/yunchao-520/p/13081153.html
Copyright © 2011-2022 走看看