• 进程 守护


    进程:  正在运行的程序(任务)   是计算机中最小的资源分配单位

      进程调度:--先来先服务调度算法,短作业优先,时间片轮转法,多级反馈队列

    并发: 微观上依次执行, 宏观上在同时执行, 同一时刻只有1个cpu在工作

    并行: 同一时刻不只1个cpu在工作 微观上就是同时执行多程序的

    同步:  程序顺序执行,多个任务之间串行执行 (洗衣完--做饭完--洗碗)

    异步:  多个任务同时运行  (在同一时间内洗衣做饭洗碗)

    I/O操作:

      input: 输出到内存 read load recv recvfrom accept input

      output: 从内存输出 write dump send sendto connect print

    阻塞: recv recvfrom accept 

      程序由于不符合某个条件或者等待某个条件满足 而在某一个地方进入等待状态

    非阻塞:

      sk.setblocking(Fasle)就让这个socket模型不阻塞了

    multiprocess模块

    multiprocess不是一个模块而是python中一个操作、管理进程的包。 之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块。由于提供的子模块非常多,为了方便大家归类记忆,我将这部分大致分为四个部分:创建进程部分,进程同步部分,进程池部分,进程之间数据共享

    process  模块是一个创建进程的模块,借助这个模块,就可以完成进程的创建

    p.start():启动进程,并调用该子进程中的p.run() 
    p.run():   进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法  
    p.terminate():强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法
              需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放,进而导致死锁 p.is_alive(): 如果p仍然运行,返回True p.join([timeout]):主线程等待p终止(强调:是主线程处于等的状态,而p是处于运行的状态)。
               timeout是可选的超时时间,需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程
    在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制),在创建子进程的时候会自动 import 启动它的这个文件,
    而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。
    所以必须把创建子进程的部分使用if __name__ ==‘__main__’ 判断保护起来,import 的时候 ,就不会递归运行了。
     
    import time
    from multiprocessing import Process
    #通过并发实现一个有并发效果的socket server
    def son_process():  #子进程
        print('son kaishi')
        time.sleep(1)
        print('son end')
    if __name__ == '__main__':
        p = Process(target=son_process) #函数名   创建子进程 先执行子进程要执行的代码
        p.start()    #实例化的对象执行方法  通知操作系统开启一个子进程
        print('主进程')
    
    非阻塞
    #结果:
    #主进程
    #son kaishi
    #son end  
    守护进程
    # 每隔1分钟主动汇报当前程序状态
    def alive():
        while True:
            print('连接监控 汇报信息')
            time.sleep(0.6)
    def func():
        #核心代码
        while True:
            print('选择项目')
            time.sleep(1)
            print('根据选择做出对应操作')
    if __name__ == '__main__':
        p = Process(target = alive)
        p.daemon = True  #子进程 设置为 守护进程 守护进程会随着主进程代码的结束而结束
        p.start()
        p = Process(target=func)
        p.start()
        p.join() #在主进程中等待子进程结束 守护进程就可以守护其他子进程了
    # 守护进程
    # 1.守护进程会等待主进程的代码结束而结束,不会等待其他子进程的结束
    # 2.要想守护进程等待其他子进程,只需要在主进程中加上join
    操作多个子进程的结束和join阻塞
    for i in range(5):
        pass
    print(i)  # i=4
    lst = []
    for i in range(5):
        p = Process()
        lst.append(p)
        p.start()
    for p in lst:
        #p.join()
        p.terminate()  #最后两个二选一

     

  • 相关阅读:
    Java后台插件(工具包)
    LINQ系列:Linq to Object联接操作符
    LINQ系列:Linq to Object排序操作符
    LINQ系列:Linq to Object限制操作符
    LINQ系列:Linq to Object投影操作符
    LINQ系列:C#中与LINQ相关特性
    设计模式笔记:简单工厂模式(Simple Factory)
    数据访问模式:数据并发控制(Data Concurrency Control)
    数据访问模式:Identity Map(标识映射)模式
    设计模式笔记:开闭原则(OCP,The Open-Closed Principle)
  • 原文地址:https://www.cnblogs.com/zhangchen-sx/p/10083815.html
Copyright © 2020-2023  润新知