day32 进程

上午：

# 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类的总结