1.并行，并发，阻塞，非阻塞，同步，异步的理解

并行：指两件或多件事情，在同一时间点同时执行
并发：指两件或多件事情，在同一时间间隔内同时执行
阻塞与非阻塞：程序运行过程中如果遇到input，或者recv(1024)需要等待用户输入，需要接收信息才能进行下一步，这个过程就叫做阻塞，否则就是非阻塞。
同步：一个任务的完成需要事件A和事件B都完成，但是事件B只有等到事件A完成才能开启自己。
异步：事件A和事件B相互独立，互不干扰。

2.多个子进程的开启

子进程的异步

代码块：同步
from multiprocessing import Process
import random
import time

def func1(i):
    print(i)


if __name__=='__main__':
    lst=list(range(50))
    for i in lst:
        p1=Process(target=func1,args=(i,))
        p1.start()  #开启p1进程

    time.sleep(3)
    res=random.choice(lst)

子进程的同步

代码块
from multiprocessing import Process
import random
import time

def func1(i):
    print(i)


if __name__=='__main__':
    lst=list(range(50))
    for i in lst:
        p1=Process(target=func1,args=(i,))
        p1.start()  #开启p1进程
        p1.join()   #join()   异步变同步,当前的执行完，才会执行下一个，这就是同步。

    time.sleep(3)
    res=random.choice(lst)

3. 多个子进程无法共享内存，会报错

代码块
from multiprocessing import Process
import random
import time

def func1(i):
    global n
    print(i,n)


if __name__=='__main__':
    n=666   #这里n是全局变量
    lst=list(range(50))
    for i in lst:
        p1=Process(target=func1,args=(i,))
        p1.start()  #开启p1进程
        # p1.join()   #join()   异步变同步,当前的执行完，才会执行下一个，这就是同步。

    time.sleep(3)
    res=random.choice(lst)

4. 开启子进程的方式

第一种：

代码块
from multiprocessing import Process
import random
import time
import os

# os.getpid()获取的是当前进程自己的pid
# os.getppid()获取的是当前进程的父进程的pid

def func1(i):
    print('我是儿子进程，我的进程号是%d,我爸爸的进程号是%d'%(os.getpid(),os.getppid()))

if __name__=='__main__':
    p=Process(target=func1,args=('wangsiyu',))
    p.name='son of process'  #给开启的子进程命名
    p.start()
    print('我是爸爸进程，我的进程号是%s'%os.getpid())

# #res:我是爸爸进程，我的进程号是14128
# 我是儿子进程，我的进程号是9888,我爸爸的进程号是14128

用继承来开启进程

代码块
from multiprocessing import Process
import random
import time
import os

class MyProcess(Process):
    def __init__(self):
        super(MyProcess, self).__init__()#  执行父类的__init__方法

    def run(self):
        print('这是以继承类的方式开启的子进程,他的名字是%s'%self.name)

if __name__ == '__main__':
    p1 = MyProcess()   #实例化对象
    p1.start()# 是指，解释器告诉操作系统，去帮我开启一个进程，   就绪状态
    # p1.run()# 告诉操作系统，现在马上帮我执行这个子进程           执行

5 如何开启多个子进程

代码块
def func(i):
    time.sleep(1)
    print('这里是儿子%s进程,儿子自己的pid是%s,儿子的父进程的pid是%s'%(i,os.getpid(),os.getppid()))

# os.getpid()获取的是当前进程自己的pid
# os.getppid()获取的是当前进程的父进程的pid
if __name__ == '__main__':
    for i in range(2):
        p = Process(target=func,args=(i,))# 实例化一个进程对象
        p.start()# 开启一个子进程,因为有range(2)循环，所以可以开启多个子进程
    print('这里是父亲进程，父进程自己的pid是：%s,父亲的父亲的pid是%s'%(os.getpid(),os.getppid()))

5. 利用p.is_alive()判断进程是否活着，用p.terminate()杀死进程

代码块

from multiprocessing import Process
import time


def func():
    time.sleep(1)
    print(123)


if __name__ == '__main__':
    p = Process(target=func)
    p.start()

    print('子进程是否还活着？', p.is_alive())
    p.terminate()  # 杀死p进程,让解释器告诉操作系统，请杀掉p进程。
    time.sleep(2)
    print('子进程是否还活着？', p.is_alive())
    # 返回一个bool值，如果返回True，代表进程还活着,如果返回False，代表子进程死了

# p.is_alive() 判断p进程是否还活着
# p.terminate() 杀死p进程

6. 守护进程

什么是守护进程

代码块
from multiprocessing import Process
import time

def func():
    time.sleep(5)
    print('这里是儿子哦')

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置
    p.start()
    time.sleep(1)
    print('这是爸爸')
# 总结一下：
#     守护进程：跟随着父进程的代码执行结束，守护进程就结束

守护进程会随着爸爸进程的结束结束，并且不能自己开子进程，会报错

代码块
from multiprocessing import Process
import time

def func1():
    print('这里是孙子')

def func():
    p = Process(target=func1)
    p.start()
    time.sleep(5)
    print('这里是儿子哦')

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置
    p.start()
    time.sleep(1)
    print('这是爸爸')
    # 守护进程：不允许开启子进程

守护进程的用法

代码块
from multiprocessing import Process
import time


def func():
    for i in range(10):
        print(time.strftime('%H:%M:%S'))
        time.sleep(1)

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置
    p.start()
    time.sleep(5)
    print('这是爸爸')

7. 进程的常用属性

代码块

from multiprocessing import Process
import time
import os

def func():
    print('这里是儿子,儿子的pid是%s'%(os.getpid()))

if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.name = 'alex'
    print('儿子的名字是%s'%p.name)
    print('儿子的pid是%s'%p.pid)
    print('儿子是不是守护进程？',p.daemon)

8. start(),join(),daemon

代码块
from multiprocessing import Process
import time

def func():
    for i in range(100):
        time.sleep(0.01)
        print('儿子在这里')

if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.join()# 是让主进程等待子进程执行完。  现象：主进程执行到这句话，主进程阻塞住，等待子进程执行
    # time.sleep(1)
    for i in range(100):
        time.sleep(0.01)
        print('爸爸在这里')

# 开启一个正常的子进程，父进程会等待子进程结束后，父进程也就是程序才结束
# p.join()# 是让主进程等待子进程执行完。  现象：主进程执行到这句话，主进程阻塞住，等待子进程执行
# 如何把父进程和子进程之间的关系变为同步或者异步？
# 父进程执行join，就会变成同步，不执行join，父进程和子进程就是异步的关系
# join必须放在start()后边，daemon必须放在shart()前边

9.今天的知识总结

代码块
from multiprocessing import Process

      获取当前进程的pid号，os.getpid()
      获取当前进程的父进程的pid号，os.getppid()

      开启子进程的方式：
         1 p = Process(target=func,args=(,))
           target: 是子进程要执行的任务
           args：是父进程给子进程传递的参数
         2 自定义类，去继承Process

      进程的方法：
          p.start()开启子进程，底层调用的是p.run()


    2 进程的两种开启方法
      (1) p = Process(target=None,args(,))
      (2) 自定义类，继承Process父类

    3 进程的常用方法
      （1） start()  开启一个子进程
      （2） join()   异步变同步（就是让父进程停留在join这句话，等待子进程执行结束，父进程再继续执行）
      （3） is_alive() 判断进程是否活着
      （4） terminate()   杀死一个进程


    4 进程的常用属性
       （1） p.name =    给p进程一个名字
       （2） p.pid       返回p进程的pid
       （3） p.daemon = True   将p进程设置为守护进程。（True为守护进程，False为普通进程）
           守护进程的两个特点：
              守护进程会随着父进程的结束而结束
              守护进程不能再创建子进程（不能要孩子）

别跑，点个赞再走