并发编程 , 孤儿进程 , 守护进程

编程类型

1. 并发 : 当任务数大于cpu核数时 , 在同一时间不同任务交替执行

2.并行 : 当任务数小于cpu核数时 , 任务同时进行

## 同步与异步之间的不同 ##

1. 同步在需要资源的时候回立即发起请求
2. 异步不会立即请求而是设置一个时间之后发起请求

## 阻塞与非阻塞的不同 ##

1. 阻塞会在发起请求后暂停线程
2. 非阻塞马上请求马上答复继续线程

3.同步( 默认同步阻塞 ) :

        当请求资源时会立即发起请求 , 同时暂停任务等待得到答复后 , 继续任务

4.同步非阻塞 : 

        当请求资源时会立即发起请求 , 立即得到答复 , 继续任务执行

5.异步阻塞 :

         当请求资源时 , 会设置一个以后的时间点 , 在这个时间点暂停任务请求资源 ,资源请求完毕后 , 继续任务执行

6.异步( 默认异步非阻塞 ):

         当请求资源时 , 会设置一个以后的时间点 , 在这个时间点立即请求资源 ,得到答复 , 继续执行任务

一.程序和进程

程序 : 一堆不会运行的代码

进程 : 一个正在运行的程序软件

程序调度：
进程执行是由操作系统决定
当进程开启的时候，都要进入就绪队列

进程优先级：
1.先来先服务
    (先到先得)从就绪队列第一个开始排
    
2.短时间优先
    在就绪队列中，选择时间短（开发人员估计）最短时间程序开始执行

3.优先级调度
    在运行时间，当有比较高的优先权的程序任务先进入，就是先执行优先权高的程序

4.时间片转轮调度
    时间片：简单来说就是cpu分配给进程时间，从各个时间片的表面是同步执行，不会浪费cpu资源
    在就绪队列中， 所有程序按照时间片给到时间程序开始执行，但是时间片用完了，继续到就绪队列中开始排队另下一个时间片继续执行

二.创建进程

# 创建进程 python自动自带multiprocessing 创建子进程库
from multiprocessing import  Process

# 创建一个任务（函数）用子进程运行
def func(name):
    print(f"{name}是子进程")

# 进程的调度是安装模板执行，防止进程无限递归调用
# 所有进程都需要用到这个来执行
if __name__ == '__main__':
    print("主进程")

    # 创建实例化Process对象
    """
        Process(target=进程执行任务的名称， args/kwargs:接受任务参数)
    """
    p1 = Process(target=func, args=("张三",))
    p2 = Process(target=func, args=("李四",))

    # 同步阻塞运行
    p1.start()
    p2.start()

三.孤儿进程 , 守护进程

1.孤儿进程

主进程结束 , 子进程继续运行

 此时子进程不受主进程控制 , 所以在Python中需要设置main函数 , 当主进程结束后 , 有init收养子进程

2.守护进程

包含两种守护

        1. 设置daemon属性为True 来实现 -- 主进程结束子进程随之结束

                ## 这里的daemon属性必须设置在start前

from multiprocessing import Process

import time

def func(name):

    time.sleep(3)

    print(f"你好, 我是子进程{name}")

if __name__ == '__main__':

    print("我是主进程")

    time.sleep(1)

    p1 = Process(target=func , args=("一号",))

    p2 = Process(target=func , args=("二号",))

   

    # 给子进程一号设置了个daemon属性 , 即为主进程结束子进程一跟着结束 , 子进程     一不受影响

 

    p1.daemon = True    daemon属性要设置在start前

    p1.start()

    p2.start()

        2.通过设置join属性来实现 -- 子进程结束后主进程才结束

# 守护进程
from multiprocessing import Process
import time
def func(name):
    print(f"你好, 我是子进程{name}")
    time.sleep(3)
    print("子进程结束")

if __name__ == '__main__':
    print("主进程结束")
    p1 = Process(target=func , args=("一号",))
    p1.start()
    p1.join()
    print("主进程结束")

四.进程数据

在进程中，各个进程数据是隔离，子进程操作的主进程数据，主进程的数据是不会受任何影响

from multiprocessing import Process

age = 10

def func():
    global age
    age += 10
    # 地理隔离， 空间隔离
    print(f"子进程：{age}")

if __name__ == '__main__':
    p1 = Process(target=func)
    p1.start()  
    p1.join()
    print(f"主进程age:{age}")

五.进程类

在Python中自带Process进程类 , 这个类是可以定义修改的 , 通过类的继承来修改类

from multiprocessing import Process

class MyProcess(Process):
    def __init__(self, name):
        super(MyProcess, self).__init__()
        self.name = name

    def eat(self):
        print(f"{self.name}一点都没有听课")

    # --> 没什么用的，就是提示作用：返回一个None，写错None也能继续正常执行
    # def run(self) -> None:
    # run 是自动运行的
    def run(self):
        print(f"{self.name}待会还在问为什么xxx")
        self.eat()

if __name__ == '__main__':
    print("主进程")
    p = MyProcess("xxxx")
    p.start()