"""
对于计算机来说，要想实现多进程(多任务)，方式是每个一段时间停止一个任务，执行下一个任务，周而复始
对于程序来说，要想实现多进程,方式也与上述相同。
当程序执行时，就是一个进程，这个进程(父进程)可以创建子进程，这时程序就有两个进程，若其中一个进程没有休息，那么另外一个进程将执行不了
因此，需要让进程在执行多久或者执行完指定的内容后休息(调用time.sleep函数)
每一个进程都有属于自己独立的储存空间，因此每创建一个进程，需要的内存空间便会很多，并且因为他们有自己的独立储存空间，
进程间相互很少往来，所以一个进度若是出现问题，是很难影响其他进程(这里是同级别的进程，不包括主进程)
由于进程的特性，使得进程间的来往需要一个FIFO队列(from multiprocessing import Queue)，才能使得进程间可以来往。而这个队列，则是由进程的父亲创建的
一般来说，一个程序对应一个进程(主进程)，这个主进程的任务就是创建和管理子进程。
"""
from multiprocessing import Process,Pool,Queue
import time,os,random
def run1():
while True:
print(os.getpid(),"根本停不下来")
time.sleep(1)
def run2(pid):
while True:
print(pid,"活力无限")
time.sleep(1.2)
def run3():
print("%s 进程执行" %(os.getpid()))
time.sleep(random.choice([1,2,3]))
print("%s 进程结束" %(os.getpid()))
def write(queue):
print("write子进程启动，%s" %(os.getpid()))
for char in ["a","b","c","d"]:
queue.put(char)
time.sleep(1)
print("write子进程结束，%s" %os.getpid())
def read(queue):
print("read子进程启动，%s" %os.getpid())
while True:
print("read:",queue.get(True))
print("read子进程结束，%s" %os.getpid())
if __name__ == "__main__": #不被引入后执行的语句，相当于主进程
# run1(),run2() #主进程，需要执行完run1函数才执行run2函数
p1 = Process(target=run1) #创建一个并指定执行的内容的进程,target值为函数名，args的为该执行函数的参数，以元组的形式
p2 = Process(target=run2,args=(os.getpid(),))
p1.start(),p2.start()
# p1.join(),p2.join() #process对象.join ,执行process对象，该进程会一直执行下去，那怕该进程休息，也还是执行该进程，不执行其他进程,直到进程结束
p1.terminate(),p2.terminate() #强行关闭进程
#若要一个个创建子进程，会比较麻烦，同时也不好管理，引用了进程池(from multiprocessing import Pool)
pool = Pool() #Pool([int]) 创建可以同时执行int的进程池,默认是CPU核心数
for i in range(6):
pool.apply_async(run3) #Pool对象.apply_async(func,[args]) 在进程池中创建一个执行func任务的子进程，args的为该执行函数的参数，以元组的形式
pool.close() #Pool对象.close() 进程池停止添加进程
pool.terminate() #强行结束线程池
pool.join() #Pool对象.join() 进程池执行进程内容，需要进程池停止添加进程后才能执行，否则报错
q = Queue() #Queue(),用于进程和线程的FIFO队列数据接口
pw = Process(target=write,args={q})
pr = Process(target=read,args={q})
pw.start(),pr.start()
print("主进程结束")
"""
封装进程对象：
"""