python学习 多进程Process/进程池Pool/队列Queue

#进程Process
from multiprocessing import Process
from time import sleep

def xx(name):
    for i in range(3):
        print('test.{}'.format(name))
        sleep(1)

if __name__ == '__main__':
    a=Process(target=xx,args=('alex',))  #----子进程做事情，主进程也可以干活
    a.start()#创建子进程
    # a.join()#等待子进程全部结束，才继续下一步执行
    a.join(timeout=1)#timeout为等待时间
    a.terminate()#强制结束
    print('main')


#Process子类创建子进程
class myProcess(Process):
    def __init__(self,name):
        Process.__init__(self)
        self.name=name

    #重写了Process类的run()方法
    def run(self):
        print('xxxx-{}'.format(self.name))

if __name__ == '__main__':
    a=myProcess('joe')
    a.start()


#进程池Pool---主进程一般用来等待，真正的任务都在子进程进行
from multiprocessing import Pool
import os

def A(name):
    for i in range(5):
        print('i-{},name-{},os-{}'.format(i,name,os.getpid()))
        sleep(1)

if __name__ == '__main__':
    po = Pool(3) #进程池中对有3个进程一起执行
    for a in range(10):
        print(a)
        po.apply_async(A,(a,))  #非堵塞模式，即一起执行
        # po.apply(A,(a,))   #堵塞模式，即依次排队执行。（该方法几乎不用）

    po.close() #关闭进程池
    po.join()


#Queue-队列（先进先出），可以作用于进程之间的通讯。
from multiprocessing import Queue
'''
q=Queue(3) #创建一个消息队列，有三个
q=Queue()  #创建一个队列，可有无数个值
q.put('hh1') #往队列存一个值
print(q.qsize()) #统计队列有多少值
print(q.get())  #从队列取一个值
print(q.empty())  #判断队列是否为空
print(q.full())  #判断队列是否是man的
print(q.get_nowait()) #不等待，立即取。队列为空的时候会报错
print(q.put_nowait('hh2')) #不等待，立即存。队列满了的时候会报错
'''
#例子-Process进程之间的通讯
from multiprocessing import Process,Queue
from time import sleep

def write(q):
    for value in ['a','b','c']:
        print('put {} in queue'.format(value))
        q.put(value)
        sleep(1)

def read(q):
    while True:
        if not q.empty():
            value1=q.get()
            print('get {} in queue'.format(value1))
            sleep(1)
        else:
            break

if __name__ == '__main__':
    q=Queue()
    #方式一----按顺序执行
    pw=Process(target=write,args=(q,))
    pw.start()
    pw.join()
    pr = Process(target=read, args=(q,))
    pr.start()
    pr.join()

    # #方式二----同时执行
    # pw=Process(target=write,args=(q,))
    # pr = Process(target=read, args=(q,))
    # pw.start()
    # pr.start()
    # pw.join()
    # pr.join()


#例子-进程池内各进程之间的通讯
from multiprocessing import Manager,Queue,Pool
from time import sleep

def writer(q):
    for i in 'alex':
        print(i)
        q.put(i)
        sleep(1)

def reader(q):
    #方式一：
    for i in range(q.qsize()):
        print(i)
        print(q.qsize())
        a=q.get()
        print('get {} in queue'.format(a))
        sleep(1)
    # #方式二：
    # while True:
    #     if not q.empty():
    #         value1=q.get()
    #         print('get {} in queue'.format(value1))
    #         sleep(1)
    #     else:
    #         break

if __name__ == '__main__':
    q=Manager().Queue()
    po=Pool()
    #方式一调用---使用阻塞模式创建进程，这样就不需要在reader中使用死循环了，可以让writer完全执行完之后，再用reader
    # po.apply(writer,(q,))
    # po.apply(reader,(q,))
    #方式二调用---使用非阻塞模式创建进程，可以writer一次同时reader一次，writer和reader一起执行
    po.apply_async(writer,(q,))
    po.apply_async(reader,(q,))
    po.close()
    po.join()


#例子---拷贝多个文件
from multiprocessing import Manager,Pool,Queue
import os

def copyFileTask(name,old_filename,new_filename,qu):
    with open(old_filename+'/'+name,'r') as f1:
        content=f1.read()
        with open(new_filename+'/'+name,'w') as f2:
            f2.write(content)
            qu.put(content)

def main():
    #1、找到要复制的文件夹名字
    old_filename=r'C:\Users\ASUS\Desktop\test'
    #2、创建新文件夹
    new_filename=old_filename+'复件'
    print(new_filename)
    os.mkdir(new_filename)
    #3、获取要复制的文件夹下所有的文件名称
    filenames=os.listdir(old_filename)
    #4、使用多进程，将旧文件内容拷贝到新文件里
    ####方法一：使用线程池多进程####
    # po=Pool(3)
    # qu=Manager().Queue()
    # for name in filenames:
    #     po.apply_async(copyFileTask,(name,old_filename,new_filename,qu))

    ####方法二：使用多进程####
    qu=Queue()
    for name in filenames:
        a=Process(target=copyFileTask,args=(name,old_filename,new_filename,qu))
        a.start()
        # a.join()

    num=0
    allNum=len(filenames)
    while True:
        qu.get()
        num=num+1
        Rate=num/allNum
        # \r 默认表示将输出的内容返回到第一个指针，这样的话，后面的内容会覆盖前面的内容
        print('\rcopy的进度是：%.2f%%'%(Rate*100),end="")
        if num==allNum:
            break

    # po.close()
    # po.join()

if __name__ == '__main__':
    main()