day39 Pyhton 并发编程02

一.内容回顾

　　并发和并行的区别

　　并发

　　　　宏观上是在同时运行的

　　　　微观上是一个一个顺序执行

　　　　同一时刻只有一个cpu在工作

　　并行

　　　　微观上就是同时执行的

　　　　同一时刻不止有一个cpu在工作

　　什么是进程

　　　　一个运行中的程序就是一个进程

　　　　是计算机中最小的资源分配单位

　　什么是同步

　　　　程序顺序执行,多个任务之间串行执行

　　什么是异步

　　　　多个任务同时运行

　　IO操作

　　　　input  输入到内存  read load recv accept recvfrom input

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

　　什么是阻塞

　　　　recv recvfrom accept

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

　　什么是非租塞

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

二.今日内容

　　multiprocessing是一个包

　　Process类

　　　　开启一个子进程

　　　　能不能给子进程传递一个参数

　　　　能不能有一个返回值

　　　　主进程控制子进程的同步

　　　　守护进程

　　　　另一种开启子进程的方式

　　Lock锁

　　　　保证数据的安全性

　　Semaphore 信号量

　　Event 事件

三.进程模块

　　1.开启了一个子进程就已经实现了并发: 父进程(主进程)和子进程并发(同时执行)　

def son_process():
    print('son start')
    time.sleep(1)
    print('son end')

if __name__ == '__main__':
    p = Process(target=son_process)
    p.start()
    for i in range(5):
        print('主进程')
        time.sleep(0.3
主进程
主进程
son start
主进程
主进程
主进程
son end

　　2.开启多个子进程

　　

def son_process():
    print('son start')
    time.sleep(1)
    print('son end')

if __name__ == '__main__':
    p1 = Process(target=son_process)
    p1.start()
    p2 = Process(target=son_process)
    p2.start()
    p3 = Process(target=son_process)
    p3.start()
son start
son start
son start
son end
son end
son end

# 开启多个子进程(二)
def son_process():
    print('son start')
    time.sleep(1)
    print('son end')

if __name__ == '__main__':
    for i in range(3):
        p = Process(target=son_process)
        p.start()
son start
son start
son start
son end
son end
son end

# 3.给子进程中传参数
def son_process(i):
    print('son start',i)
    time.sleep(1)
    print('son end',i)

if __name__ == '__main__':
    for i in range(10):
        p = Process(target=son_process,args=(i,))
        p.start()  # 通知操作系统 start并不意味着子进程已经开始了

# 4.主进程和子进程之间的关系
def son_process(i):
    print('son start',i)
    time.sleep(1)
    print('son end',i)

if __name__ == '__main__':
    for i in range(10):
        p = Process(target=son_process,args=(i,))
        p.start()
    print('主进程的代码执行完毕')
# 主进程会等待子进程结束之后才结束
# 父进程负责创建子进程,也负责回收子进程的资源
主进程的代码执行完毕
son start 3
son start 5
son start 4
son start 2
son start 0
son start 6
son start 7
son start 1
son start 9
son start 8
son end 3
son end 5
son end 4
son end 2
son end 0
son end 6
son end 7
son end 1
son end 9
son end 8

# 5.主进程不可以直接结束一个子进程
def son_process(i):
    while True:
        print('son start',i)
        time.sleep(0.5)
        print('son end',i)

if __name__ == '__main__':
    p = Process(target=son_process, args=(1,))
    p.start()           # 开启一个子进程,异步的
    print('主进程的代码执行完毕')
    print(p.is_alive())  # 子进程还活着
    p.terminate()        # 结束一个子进程,异步的
    print(p.is_alive())  # 子进程还在活着
    time.sleep(0.1)
    print(p.is_alive())

# 6.进程之间数据隔离的概念
n = [100]
def sub_n():
    global n  # 子进程对于主进程中的全局变量的修改是不生效的
    n.append(1)
    print('子进程n : ',n)
if __name__ == '__main__':
    p = Process(target = sub_n)
    p.start()
    p.join()     # 阻塞 直到子进程p结束
    print('主进程n : ',n)
子进程n :  [100, 1]
主进程n :  [100]

# 7.开启十个进程执行subn
# 主进程里的print('主进程n : ',n)这句话在十个子进程执行完毕之后才执行
n = [100]
import random
def sub_n():
    global n  # 子进程对于主进程中的全局变量的修改是不生效的
    time.sleep(random.random())
    n.append(1)
    print('子进程n : ',n)
if __name__ == '__main__':
    p_lst = []
    for i in range(10):
        p = Process(target = sub_n)
        p.start()
        p_lst.append(p)
    for p in p_lst:p.join()  # 阻塞 只有一个条件是能够让我继续执行 这个条件就是子进程结束
    print('主进程n : ',n)

# 8.join的扩展
n = [100]
def sub_n():
    global n  # 子进程对于主进程中的全局变量的修改是不生效的
    n.append(1)
    print('子进程n : ',n)
    time.sleep(10)
    print('子进程结束')

if __name__ == '__main__':
    p = Process(target = sub_n)
    p.start()
    p.join(timeout = 5)     # 如果不设置超时时间 join会阻塞直到子进程p结束
    # timeout超时
    # 如果设置的超时时间,那么意味着如果不足5s子进程结束了,程序结束阻塞
    # 如果超过5s还没有结束,那么也结束阻塞
    print('主进程n : ',n)
    # p.terminate()  # 也可以强制结束一个子进程

守护进程:
　　什么是守护进程

　　监控系统

　　每隔1min中主动汇报当前程序的状态

import time
from multiprocessing import Process
def alive():
    while True:
        print('连接监控程序,并且发送报活信息')

def func():
    '主进程中的核心代码'
    while True:
        print('选择的项目')
        time.sleep(0.5)
        print('根据用户的选择做一些事儿')

if __name__ == '__main__':
    p = Process(target=alive)
    p.daemon = True   # 设置子进程为守护进程,守护进程会随着主进程代码的结束而结束
    p.start()
    time.sleep(5)
    p = Process(target=func)
    p.start()

# 设置子进程为守护进程,守护进程会随着主进程代码的结束而结束
# 由于主进程要负责给所有的子进程收尸,所以主进程必须是最后结束,守护进程只能在主进程的代码结束之后就认为主进程结束了
# 守护进程在主进程的代码结束之后就结束了,不会等待其他子进程结束

守护进程必须等待所有的子进程结束之后才结束

import time
from multiprocessing import Process
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()   # 在主进程中等待子进程结束,守护进程就可以帮助守护其他子进程了