进程和操作系统

计算机操作系统发展史
#多道技术
　　1.空间复用：
　　　　同一时间在内存中存放多个程序 内存相互隔离
　　2.时间复用：
　　　　CPU在遇到IO时切换到另一个程序
　　可以实现并发
　　　　切换+保存状态


#进程理论：
进程和程序的区别：
    程序是什么？
        本质就是一堆代码文件
        一个程序正在被操作系统读取操作并执行 就变成了进程
一个程序只能有一个进程嘛？
    可以 启动一次就产生一个进程 当然可以用代码控制是否允许多进程

#进程的概念起源于操作系统,进程是操作系统最核心的概念,操作系统其它所有的概念都是围绕进程来

    操作系统理论:
        1. 操作系统是什么?
            操作系统是一个协调管理控制计算机硬件资源与应用软件资源的一段控制程序
            有两大功能:
                1. 将复杂的硬件操作封装成简单的接口给应用程序或者用户去使用
                2. 将多个进程对硬件的竞争变得有序

    操作系统发展史
        并发: 多个任务看起来是同时运行的
        串行:一个任务完完整整地运行完毕,才能运行下一个任务

        多道技术:(复用=>共享/共用)
            1. 空间上的复用:多个任务复用内存空间
            2. 时间上的复用:多个任务复用cpu的时间
                1. 一个任务占用cpu时间过长会被操作系统强行剥夺走cpu的执行权限:比起串行执行反而会降低效率
                2. 一个任务遇到io操作也会被操作系统强行剥夺走cpu的执行权限:比起串行执行可以提升效率

启动进程的方式
    1.系统初始化 会产生一个根进程
    2.用户的交互请求 鼠标双击某个程序
    3.在一个进程中 发起了系统调用启动了另一个进程******
    4.批处理作业开始 某些专用计算机可能还在使用

每个操作系统创建进程的方式不同
    unix <  centos  mac  linux
    linux 下创建进程 会直接将父进程的所有数据复制一份给子进程
    windows 创建进程时 子进程会加载父进程的字节码（没有多余符号）

开启子进程：
    子进程会把父进程的内容加载一份到自己的内存空间，两个进程之间的数据是互不干涉的
    在开启子进程时，子进程开启写在if __name__ == '__main__':开启否则会重复开启新的
    子进程无法正常运行
    主进程和子进程是处于并发编程的，没有执行顺序一说
    我们的代码只负责通知操作系统创建进程 创建完就继续其他代码
    系统什么时候创建完成，什么时候执行代码是我们无法预知的

    开启子进程以及父进程在子进程后执行的例子：
        from  multiprocessing import Process
        import time,os
        def  task(name):
            print("这是一个程序%s"%name)
            time.sleep(4)
            print("结束时候%s"%name)
        if __name__ == '__main__':
            p=Process(target=task,args=("egon",))
            p.start()
            print("主程序pid %s，主程序父pid %s"%(os.getpid(),os.getppid()))
            print("zi进程pid %s"%p.pid)
            #p.join主进程会等子进程结束
            p.join(2)#主进程会等子进程2秒后再继续执行
            print("这是主")

    验证进程间是并发执行例子：
    from  multiprocessing import Process
    import time,os
    def  task(name):
        print("这是一个程序%s"%name)
        time.sleep(4)
        print("结束时候%s"%name)
    if __name__ == '__main__':
        start=time.time()
        ps=[]
        for i in range(1,3):
            p=Process(target=task,args=(i,))
            p.start()
            ps.append(p)
        print("主程序pid %s，主程序父pid %s"%(os.getpid(),os.getppid()))
        print("zi进程pid %s"%p.pid)
        for p in ps:
            p.join()
        print("这是主",time.time()-start)

第二种开启子进程方式继承的是run函数:
    from multiprocessing import Process
    #记住语法
    class MyProcess(Process):
        #当进程被执行时 其实执行的就是run函数
        def run(self):#你要做的事情放在run中
            print("run被执行了")
    if __name__ == '__main__':
        mp=MyProcess()
        mp.start()

进程对象常用的属性：
    if __name__ == '__main__':
        p = Process(target=task, args=("egon",))
        p.start()
        print("主程序pid %s，主程序父pid %s" % (os.getpid(), os.getppid()))
        print("zi进程pid %s" % p.pid)
        # p.join主进程会等子进程结束
        p.join()  # 主进程会等子进程2秒后再继续执行 使父进程让出cou执行权
        print(p.name)#进程名称
        print(p.pid)#h获取这个子进程的id
        p.terminate()#结束字进程
        time.sleep(2)
        print(p.is_alive())#判断进程是否存活，会有一点点时间延迟
        print("这是主")

        #p这个进程的父进程 是 “执行文件”这个进程
        import os
        print(os.getpid())#当前自己进程的id
        print(os.getppid())#pycharm的进程id

        #父进程如何获取子进程中的数据，跨进程读取

僵尸进程和孤儿进程
    僵尸进程：一个进程任务执行完就死亡了 但是操作系统不会立即将其清理 为的是
        开启这个子进程的父进程可以访问的这个子进程的id
        这样的完成任务的但未被系统清理的僵尸进程 越少越好

    孤儿进程：一个父进程已经死亡 可然而他的子孙进程 还在执行着 这时候操作系统
        会接管这些孤儿进程。它们是对系统无害的