day 32 子进程的开启 及其用法

 开启两种子进程的两种方式
# # # 1 传统方式
# from multiprocessing import Process
# import time
# def task(name):
#     print ('%s is runing'%name)
#     time.sleep(2)
# if __name__ == '__main__': #在windows 系统下,开子进程的代码必须写到这一行下面
#     p1 = Process(target= task,args = ('xiaowang',))    # 因为args 是个动态传参 是个他的结果是个元祖
#     p2 = Process(target= task,kwargs={'name':'xiaoluo',})   # kwargs 是字典传参 上传的是键                                           # ，加个逗号才是元祖形式
# #     #  知识点补充 函数传参的话： 在形参角度上，位置参数，*args (动态参数 返回的是元祖)，
# #     # 默认参数（等于的那个）**kwargs(动态参数返回的是字典)
#     p1.start()   #只是在在给操作系统发一个一个信号，让操作系统去开进程，（申请内存+拷贝父进程的地址控制）
#     p2.start()
#     print('我是主进程')
#     # 结果：
    # 我是主进程
    # xiaowang is runing
    # xiaoluo is runing

    # 总结开个子进程，子进程和主进程并发运行（看起来是并行），先运行主进程在运行子进程，提升效率。
    # 格式：
    # 引用 from  multiprocessing import  Process
    #      def  函数名（传参）：
    # 实例化 子进程对象=Process(函数名，动态参数（因为不确定上传的）=元祖形式)
    #     注意*args = 元祖 因为 如果他在形参的角度上 实参上传后返回的是元祖
    #     然而在实参这里 只有现在是元祖上 打印出才是字符串
    # 然后开启 进程 子进程对象.start() 固定格式
    # 以下就是主进程
# 子进程的方法1 例子1 传统
# from  multiprocessing import Process
# import time
# def eat(name):
#     print('%s 正在吃饭'% name)
#     time.sleep(2)
# if __name__ == '__main__':
#     role = Process(target = eat, args = ('子进程儿子王牧天',))  # 易错点 重点看
#     role.start()
#     print('我才是主进程爸爸')
#     我才是主进程爸爸
#     子进程儿子王牧天
#     正在吃饭
# 子进程的方法二  自定义的开启子进程的方法 但是不常用了解就行了
# import time
# from multiprocessing import Process
# import time
# class Myprocess(Process):
#     def __init__(self,name):
#         super().__init__()  #继承父类
#         self.name = name
#     def run(self):
#         time.sleep(2)
#         print('%s正在学习'% self.name)   # %s s 必须是小写
# if __name__ =='__main__':
#     p = Myprocess('小花')
#     p.start()
#     print('我是主进程')
#     我是主进程
#     小花正在学习
# -------- ---------------------------
# 关于join的用法 意思就是 在子进程打印完成后才打印主进程
#每个对象加join 必须每个子进程运行完后在运行主进程
# from  multiprocessing import Process
# import time
# def eat(name):
#     print('%s 正在吃饭'% name)
#     time.sleep(2)
# if __name__ == '__main__':
#     role1 = Process(target = eat, args = ('子进程儿子王牧天',))  # 易错点 重点看
#     ## role.start()
    # #role.join()
    #print('我才是主进程爸爸')
    # 结果：
    # 子进程儿子王牧天
    # 正在吃饭
    # 我才是主进程爸爸
    # role2 = Process(target=eat, args=('子进程媳妇小罗',))
    # role3 = Process(target=eat, args=('子进程小馒头',))
    # role1.start()
    # role2.start()
    # role3.start()
    # role1.join()
    # role2.join()
    # role3.join()
    # print('我是主进程遇到子进程的join 了')
    # 子进程媳妇小罗
    # 正在吃饭
    # 子进程儿子王牧天
    # 正在吃饭
    # 子进程小馒头
    # 正在吃饭
    # 我是主进程遇到子进程的join了
# -----------
# # 子进程对象 为了节省代码 运用for 循环
# from  multiprocessing import Process
# import time
# def eat(name):
#     time.sleep(3)
#     print('%s 正在吃饭'% name)
# if __name__ == '__main__':
#     role1 = Process(target = eat, args = ('子进程儿子王牧天',))  # 易错点 重点看
#     role2 = Process(target=eat, kwargs={'name':'子进程媳妇小罗'})
#     role3 = Process(target=eat, args=('我是小王了',))
#     role_list=[role1,role2,role3]
#     for role in role_list:
#         role.start()
#     for role in role_list:
#         role.join()
#     print('我是主进程遇到子进程的join 了')   #for循环的位置子进程加上join 就会等到子进程完毕在开始
    # 子进程儿子王牧天正在吃饭
    # 我是小王了正在吃饭
    # 子进程媳妇小罗正在吃饭
    # 我是主进程遇到子进程的join了
# print('我是主进程遇到子进程的join 了')   #子进程加上join 就会等到子进程完毕在开始
#     我是主进程遇到子进程的join 了
#     我是主进程遇到子进程的join 了
#     我是主进程遇到子进程的join 了
#     子进程儿子王牧天 正在吃饭
#     子进程媳妇小罗 正在吃饭
#     我是小王了 正在吃饭
#     我是主进程遇到子进程的join 了
# -------------------------
#    #os.getpid()   此处进程的id号码
#    在cmd 中运行  tasklist 的意思就是计算机中所有的进程
#         找到python里面的文件的进程  在cmd中 tasklist |管道符  findstr  python  就会找到python的进程
#         tasklist |findlist python
# import time,os
# print(os.getpid())      #3404
# time.sleep(1000)
# 显示当前的文件的id
# ----------------------------
# 其他方法的子孙三代的例子
# from multiprocessing import Process
# import time,random
# def task():
#     print('孙子运行了')
#     time.sleep(3)
# def piao(name):
#     print('%s is piaoing' % name)
#     time.sleep(random.randint(1, 3))
#     print('%s is done' % name)
#     p=Process(target=task,)   #子类 再次实行实例化 孙子的子进程
#     p.start()
# if __name__ == '__main__':
#     p1=Process(target=piao,args=('alex',),name='xxxxxxxx')
#     p1.start()
    # print('主')
    # 主
    # alex is piaoing
    # alex is done
    # 孙子运行了
# ----------------
#     print(p1.name)   #这样的组合 会先打印对象里的 然后再是主进程 然后是子进程 最后是孙子进程
#     print('猪')
    # xxxxxxxx
    # 猪
    # alex is piaoing
    # alex is done
    # 孙子运行了
    # --------------
    # p1.join()
    # print('主')
    #先打印子进程 然后就是孙进程 最后是主程序
    # alex is piaoing
    # alex is done
    # 孙子运行了
    # 主
    # --------------------
    # p1.terminate()  #杀死子进程  但是需要时间 马上打印的话 下边是活的
    # print(p1.is_alive())   # 判断子进程是不是活着的
    # ----------------
    # p1.join(timeout=1)  # 超过1秒就不等他了
    # print('主')
    # -----------------------
    #
    # 进程池
    # 提交 / 调用任务的方式有两种：
    # 同步调用：提交 / 调用一个任务，然后就在原地等着，等到该任务执行完毕拿到结果，
    # 再执行下一行代码
    # 异步调用: 提交 / 调用一个任务，不在原地等着，直接执行下一行代码，结果？
    # from multiprocessing import Process,Pool  这个是开启子进程 但是后期会不好用
   # --------------------------------------

# from concurrent.futures import ProcessPoolExecutor    # #新式的开进程
# import time, random,os
# def piao(name):
#     print('%s is piaoing %s' % (name, os.getpid()))   #   #获得进程的id的
#     time.sleep(5)
# if __name__ == '__main__':
#     p = ProcessPoolExecutor(4)
#     for i in range(10):
#         p.submit(piao,'wang%s'%i)
#     print('主程序',os.getpid())
# 先打主程序，然后四个四个的打印 。


# from concurrent.futures import ProcessPoolExecutor
# import time, random, os
#
# def piao(name, n):
#     print('%s is piaoing %s' % (name, os.getpid()))
#     time.sleep(1)
#     return n ** 2
# if __name__ == '__main__':
#     p = ProcessPoolExecutor(4)
#     objs = []
#     start = time.time()
# for i in range(10):
#     # res=p.submit(piao,'alex %s' %i,i).result() #同步调用
#     # print(res)
#     obj = p.submit(piao, 'alex %s' % i, i)  # 异步调用
#     objs.append(obj)
#
# for obj in objs:
#     print(obj.result())
#     stop = time.time()
#     print(stop - start)
# #     # 关门+等
# #     # pool.close()
# #     # pool.join()
#     p.shutdown(wait=True)
#     print('主', os.getpid())