开启两种子进程的两种方式
# # # 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())