PYTHON-进程 子进程

并发编程
    学习目标: 见35复习

1、操作系统
       什么是操作系统
       操作系统的两大作用：
       批处理操作系统：
   操作系统发展史:
      多道技术*****
        产生背景：
        两大核心点：
      应用软件的优化的核心:*****

2、进程
    1、进程理论（*****）
        1、进程与程序区别
        2、并发,并行,串行是什么
        3、不同操作系统开启子进程的区别
        4、一个进程的三种运行状态
    2、开启进程的两种方式（*****）
    3.多进程的执行顺序 ******
    4、进程对象的常用属性
    5 僵尸进程和孤儿进程(了解)**

    6、守护进程（**） 见36复习
    7、互斥锁与信号量（**）
        是什么
        为什么使用
        互斥锁与join的区别：
        如何使用
        注意强调点
        Semaphore信号量(了解)
    8、IPC机制：队列，管道（*）
      三种方式
    9、进程queue=管道+锁 （***）

    10、生产者消费者模型（*****） 见37复习
        1、什么是生产者消费者模型？
        2、什么用生产者消费者模型？
        3、为什么要用生产者消费者模型？好处？
        4、如何实现？
        总结点

3、线程
      1、线程理论（*****）见37复习
          1、是什么
          2、线程vs进程
      2、开启线程的两种方式（*****）
      3、守护线程（**）

      4、互斥锁与信号量（**）见38复习
      5、GIL vs 互斥锁（*****）
          1、什么是GIL
          2、GIL的影响
          3、GIL的优缺点：
          4、GIL vs 互斥锁
        6 Cpython的解释器下*****
      7、死锁现象与递归锁（**）
      8、线程queue（***）
      9、Event事件（**）

4、池（*****）见38复习
    是什么
    为何要用池：
    什么时候用池：
    如何用池？
    总结点

5、单线程下实现并发（***） 见39复习
    1 同步调用 异步调用+回调机制
        提交任务的两种方式：
        什么是同步异步
        任务执行的三种状态：
         同步调用vs阻塞,两种不同的'等'的效果

        异步回调  ******
            什么是异步回调?
            为什么需要回调?(比如 烧水壶,水烧开后 水壶会发出响声)
            注意点:
            回调函数什么时候被执行?
            谁在执行回调函数?
            线程的异步回调

    2.线程队列 **
        队列
        堆栈
        优先级队列

    3、单线程下实现并发（***）
            什么是协程
                并发
                并发实现的本质=切换+保存状态(两类切换)
            高性能分析：
            为什么需要协程
            如何实现协程(三种)
            协程的应用场景:
            总结点:

6、网络IO模型（主要掌握理论***） 见40复习
    网络传输中的两个阶段
    1.阻塞IO
    2.非阻塞IO
    3.多路复用
    4.异步IO

sockserver

---------------------------------------------------
并发编程
    学习目标:让服务器能够支持高并发+高性能

1、什么是操作系统
        操作系统是位于计算机硬件与应用软件之间
        用于协调、控制、管理计算机硬件与软件的资源的一种控制程序

   操作系统的两大作用：
    1、把复杂丑陋的硬件操作都封装成美丽的接口，提供给应用程序使用
    2、把进程对硬件的竞争变的有序

  操作系统发展史:
    第一代计算机 程序是固定 无法修改 某种计算机只能干某种活
    第二代计算机 批处理系统 需要人工参与 将程序攒成一批 统一执行
                串行执行 提高计算机的利用率 但是调试麻烦
       批处理操作系统：（串行）
            把程序员的程序攒成一堆
            然后批处理系统读一道程序到内存然后执行
            执行完毕后输出，然后才能读入下一道程序。。。

    第三代计算机 为了更好利用计算机资源 ,产生了多道技术

  多道技术*****
    产生背景：在单核背景下实现多个进程并发执行的效果

    两大核心点：
    1、空间上的复用 （多道程序复用内存的空间）
        内存分割为多个区域 每个区域存储不同的应用程序
        内存中同时读入多道程序,多道程序的内存空间是物理隔离的

    2、时间上的复用  （多道程序复用CPU时间）
        切换+保存状态
        1 正在执行的进程遇到IO操作时 会切换到其它程序
            可以提高效率
        2 运行时间过长 或者有一个优先级更高的进程抢走了CPU
            反而会降低效率
        (当然因为cpu速度贼快 用户感觉不到)
!!!!!应用软件的优化:最核心的优化就是减少IO操作,减少对硬盘的读写操作

2、进程
    1、进程理论（*****）
        进程：正在进行的一个过程或者说一个任务。而负责执行任务则是cpu。
       举例（单核+多道，实现多个进程的并发执行）：
        egon在一个时间段内有很多任务要做：python备课的任务，写书的任务，交女朋友的任务，王者荣耀上分的任务，　　
        但egon同一时刻只能做一个任务（cpu同一时间只能干一个活），如何才能玩出多个任务并发执行的效果？
        egon备一会课，再去跟李杰的女朋友聊聊天，再去打一会王者荣耀....这就保证了每个任务都在进行中.

     进程与程序区别
        程序说白了就是一堆文件
        进程就是一个正在执行的过程/程序 是一个资源单位

        2、并发与并行
        并发：看起来同时运行，实际上 不同任务间来回切换
            单核就可以实现并发，但是单核无法实现并行
        并行：真正意义上的同时运行，一个cpu同一时刻只能做一件事
            只有多核才能同时做多件事，即并行的效果
        串行：按照固定的顺序一个个地执行(第一个任务没执行完 第二个只能等待)

        3、不同操作系统开启子进程的区别
            windows-CreateProcess
            unix-fork
            都会拷贝父进程的状态,
            区别点是unix系统fork拷贝的子进程的初始状态和父进程一模一样.

            进程的终止
            windows-ExitProcess
            unix-exit

        4、一个进程的三种运行状态
            运行态(正在执行)-
            阻塞态(遇到IO)-
            就绪态(运行时间过长/有优先级更高的抢走CPU)

            只有运行态和就绪态可以来回切换
            阻塞态切换到运行态时 需要经过就绪态

    2、开启进程的两种方式（*****）
        1.直接实例化Process这个类 参数target中传入任务函数
        2.继承Process类 实现run函数
       方式一：
        from multiprocessing import Process
        import os,time

        def task(name):
            print('%s is running' %os.getpad())

        if __name__ == '__main__':
            obj=Process(taget=task,args=('egon',))
            obj.start() # 发送信号给操作系统
            print('主')

       方式二：
        from multiprocessing import Process
        import os,time

        class Work(Process):
            def run(self):
                print('%s is ruuning' %self.pid)
                time.sleep(3)

        if __name__ == '__main__':
            obj=Work()
            obj.start() # 发送信号给操作系统
            print('主')
    (启动进程的方式
        1.系统初始化 会产生一个根进程
        2.用户的交互请求 鼠标双击某个程序
        3.在一个进程中 发起了系统调用启动了另一个进程 ******
        4.批处理作业开始 某些专用计算机可能还在使用)

    3.多进程的执行顺序 ******
        主进程必然先执行
        子进程应该在主进程执行后执行
        一旦子进程启动了 后续的顺序就无法控制了

    4、进程对象的常用属性
        obj.start() 开启进程
        obj.join(1) 父进程等待子进程

        obj.terminate() 终止进程
        obj.is_alive()  是否存活

        obj.pid  获取进程id
        obj.name 进程名称

        "我是主程序我的pid:%s 我的父进程是:%s" % (os.getpid(),os.getppid())
        "我有一个儿子是 %s" % obj.pid

    5 僵尸进程和孤儿进程(了解)**
        僵尸进程:有害
            一个子进程任务执行完就死亡了 但是操作系统不会立即将其清理
            为的是 开启这个子进程的父进程可以访问到这个子进程的信息(如PID)
            这样已完成任务的 但是没有被操作系统清理的进程称为僵尸进程
            直到父进程结束后发起调用回收子进程(减少PID占用),僵尸进程越少越好

        孤儿进程:无害!
            没有爹的称为孤儿
            一个父进程已经死亡 然而他的子孙进程还在执行着  这时候操作系统会接管这些孤儿进程