上午：
# 1 开启子进程
#target
#args
# if __name__ == '__main__'
#start()
# 2.其它的方法：
#方法：
#terminate()
#is_alive()
#属性
#pid
#name
# 3. 开启多个子进程
# 4.join
#阻塞等待一个子进程结束
#阻塞等待多个子进程结束
#5. 守护进程 #6.面向对象的方式实现多进程
1内容回顾
#__author : 'liuyang'
#date : 2019/4/15 0015 上午 9:12
# io输入 ：输入到内存
# 输出 ： 从内存中输出到硬盘 # 操作系统
#单道
#多道
#分时
#并发和并行
#多个程序在一个cpu上交替 运行
#在多个cpu上多个程序 #快 # 阻塞和非阻塞
#在工作 ：非阻塞 # 同步和异步
#调用一个程序，需要等待这个任务执行完后并返回结果，现在的代码才能运行
#掉一个任务，不关系这个任务是否完成，只负责调用，余下的内容 # 进程和程序
# 正在执行的程序
#统进行资源分配和调度的基本单位
#多个进程之间的数据相互隔离
# pid唯一标识 可变 另次运行 #进程的创建 和结束
#系统初始化
# 子进程
#交互式请求
# 结束： 正常退出
# 出错退出：自愿（自己设计的）
#严重错误：
#杀死了一个子进程 # 进程的调度
#先来先服务
#短作业优先
#分时/多道（遇到IO把cpu让出来）
#多级反馈队列
# 先 短 分 都有 尤其是短，因为短作业第一优先就执行
# 第一级 时间短 执行不完的被下放
#但是 下面的优先级低 执行时间长 #比较合理 # 阻塞 是 干别的事吗？ # 登录
# input()
# input()
# 判断用户名密码 # 不在第一优先级了 因为被阻塞 占了
import sys
print(sys.argv)
if sys.argv[1] == 'aa' and sys.argv[2] =='aaa':
print('登陆成功')
# 把放在一个列表中 类似于 *args
# 启动的同时 把用户名和密码放进去
2.今日内容
# 使用模块
# multiprocessing 一个多元化的进程模块
# multiple 多元化 processing 进程
#涵盖了和进程相关的几乎 所有的内容
#process 类 帮助你启动\停止进程
# Lock 类 锁
# Queue 类
3.process类的使用
#__author : 'liuyang'
#date : 2019/4/15 0015 上午 10:12
import time
import os
# def func(i):
# time.sleep(1)
# print(i,os.getpid())
# print('主：',os.getpid())
#
# func(0)
# func(1)
# func(2)
# # 同步 执行完 0 再1 再 2
# 2 .使用process 穿件一个类
'''
from multiprocessing import Process # 包 #类包 大写
def func( ):
time.sleep(1)
print(0,os.getpid(),os.getppid())# pid processid ppid:parent process id # Processs 进程类
if __name__ == '__main__': #多进程 是因为这里 多个操作一个文件
# windows 操作系统下开启子进程，子进程中的代码是通过import 这种方式被导入到子进程中的
# 要想不一直 循环父创子 子创子 都放到if 判断里
# mac，linux 是 copy到这来的 不需要if
Process(target=func).start()
Process(target=func).start()
Process(target=func).start() #异步 不影响别的执行
# func的参数怎么传递
# func 不能 + 括号 加括号立刻执行 print(func())
'''
# 怎么证明是多个进程 # 几个概念
#子进程 #互不干扰
#父进程
#主进程 ：run的是主 同时也是父进程 # if __name__ = '__mian__' #和进程原本没有关系
'''
def func(a,b,c):
time.sleep(1)
print(a,b,c,os.getpid()) print('主：',os.getpid()) # 传参 #还没开启进程（没隔离）中就已经加入 所以可以传参
from multiprocessing import Process # 包 #类包 大写
if __name__ == '__main__':
Process(target=func,args=(1,2,3)).start() # 1、func的返回值能返回到父进程中么？ 不行 进程开启后隔离了
#进程之间数据隔离，所以子进程中的返回值父进程获取不到 # 异步的现象
# Process 进程类
if __name__ == '__main__':
p = Process(target=func,args=(1,2,3))
p.start() #p是一个进程操作符 #操作系统有空的时候开始
print(p.is_alive())
p.terminate() #终止结束一个进程
# 异步非阻塞模型 各干各的 不等待 干完了就干
# 操作系统有空的时候结束
print(p.is_alive())
time.sleep(0.1)
print(p.is_alive())
print(p.name,p.pid) #Process-2 8488 #名字随机分布的 if __name__ == '__main__':
for i in range(1,4):
Process(target=func, args=(i,i+1,i+2)).start() # 2. process类
# 3.进程中的其它方法
# 4.如何开启多个子进程
from multiprocessing import Process
import random
def send_mail(name): time.sleep(random.uniform(1,3))
print('已经给%s发送邮件完毕'%name)
if __name__ =='__main__':
lst = ['liu','wang','zhang']
# 阻塞等在 子进程结束之后
p_l = []
for name in lst :
p = Process(target=send_mail , args=(name,)) #必须元组
p.start() #异步非阻塞 #发信息需要时间
# 这样缩进同步了
#p.join() #这样阻塞，直到p对应的进程结束之后才结束阻塞 #这个思路以后会经常的用到在以后
#现在不着急用， 都执行完了 每个都用 先加入 列表中
p_l.append(p) for p in p_l : p.join() # 执行完了没有 ，每一个进程分别join
print('所有的信息发送完毕了') #然后这里就抽空执行了 # '''
# 所有的信息发送完毕了
# 已经给wang发送邮件完毕
# 已经给liu发送邮件完毕
# 已经给zhang发送邮件完毕'''
# 同时发 并发 效率
# '''
#守护进程 #主进程结束 守护进程也结束 然后子进程结束
import time
from multiprocessing import Process
def func():
# while True:
for i in range(20):
time.sleep(0.5)
print('in func')
def func2():
print('start: func2')
time.sleep(5)
print('end: func2') if __name__ == '__main__':
p = Process(target=func) p.daemon = True #表示设置p为一个守护进程
p.start() #结束主代码，结束 不管子进程
p2 = Process(target=func2)
p2.start()
print('in main')
time.sleep(3)
print('finished')
# p2.join() # 这样可以 子进程 。阻塞在这 可以等到子进程也结束 # name 里的 func（）里的
# 主进程 和 子进程互不干扰
# 主进程执行完毕之后 , 会等到所有子进程结束之后
# 为什么
# 父进程要负责回收子进程的 系统资源 防止一直占用 #守护进程：
#是一个子进程，守护的是主进程
#结束条件：主进程的代码结束，（主进程结束，代码还没结束，等待着子进程收尸），守护进程也结束
# 因为守护进程也是子进程（要被主进程回收），所以没法守护到主进程完全结束 # 进程
#主进程的代码结束，守护进程结束
#主进程要挥手进程（子进程）的资源
#等待其他所有子进程结束
#主进程回收所有子进程的资源 # 迭代器生成器（把变量删掉，是内存中的资源，不操作系统） 内存中的数据 资源 都不需要回收 垃圾回收机制
#内存中的这个变量 join 自己程序的级别里
#操作系统 程序里 不能删掉这个变量
# 但是操作系统的资源的 进程
#需要主进程来回收
4 和 5 的 __name__
#__author : 'liuyang'
#date : 2019/4/15 0015 上午 10:43
import name_demo
# print()
# 'name_demo': <module 'name_demo' from 'D:\\Python\\S20\\day32\\name_demo.py'>
#
4__name__
#__author : 'liuyang'
#date : 2019/4/15 0015 上午 10:41
# print(__file__) #内置文件中的变量
# print(__all__) # 列表里写啥 ，就可以显示啥 print([__name__]) #['__main__'] # 看当前这句话是怎么被执行的
#1. 右键直接执行 [__name__] = ['__main__']
#2. 导入这个模块执行 [__name__]= ['name_demo']
# 变量 sys.modules[__name__] 太棒了 联系
import sys
print(sys.modules)
# sys.modules[__name__]
#<module '__main__' from 'D:/Python/S20/day32/name_demo.py'>,
#用name 找到文件了
#执行的任意一个文件 name 都是 __main__
#但是被别人导入了 name 就变成了导入的文件的名字了 def func():
print('in func') if __name__ == '__main__':
func() #写的所有代码是不希望这个文件作为模块被导入的时候执行的代码
5 name_demo
6. 面向对象的多线程
#__author : 'liuyang'
#date : 2019/4/15 0015 下午 12:23
# 1 开启子进程
#target
#args
# if __name__ == '__main__'
#start()
# 2.其它的方法：
#方法：
#terminate()
#is_alive()
#属性
#pid
#name
# 3. 开启多个子进程
# 4.join
#阻塞等待一个子进程结束
#阻塞等待多个子进程结束
#5. 守护进程 #6.面向对象的方式实现多进程
import os
from multiprocessing import Process
class MyProcess(Process):
def __init__(self,a,b):
super().__init__()
self.a = a
self.b = b
def run(self): #希望在子进程中执行的代码就放到run方法中
print(os.getpid(),self.a ,self.b) #在这里写 # def start(self): # 希望在子进程中执行的代码就放到run方法中
# print(os.getpid(), self.a, self.b) # 在这里写 # def start(self): #希望在子进程中执行的代码就放到run方法中
# print(os.getpid()) #在这里写 if __name__ == '__main__':
# for i in range(10):
MyProcess(1,2).start() #通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法
MyProcess(1,2).start()#通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法
MyProcess(1,2).start()#通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法
MyProcess(1, 2).start() # 通知操作系统开进程，执行run方法 # 明天默写
#0.内容回顾的概念
#1.使用multiprocess 起一个最简单的进程，执行查看子进程的进程id
#2.使用多进程实现socket tcp协议的并发server端
#博客上有答案 # 敏捷编程 每一天都有一个任务 迅速提升 ，就像下象棋
# 不断的推翻自己的代码 数据结构什么的
process类的总结