多任务--进程（应用较少）

1.进程的注意事项和和线程的区别

1.进程和线程的区别：

• 进程：好像是在一台电脑上多开的qq–资源分配的综合（单位）
• 线程：好像是一台电脑上一个qq中多开的聊天窗口–可以共享资源–资源调度的单位

2.注意

• 进程在实际应用中使用较少，因为他会重复复制代码和资源，导致代码和数据的冗余，可以使用线程或者协程

2.使用进程实现多任务

#使用进程实现多任务--代码共享--共享同一份代码不进行复制，但是可以那么理解
import time
import multiprocessing

def tes1():
    while True:
        print("1------")
        time.sleep(1)

def tes2():
    while True:
        print("2------")
        time.sleep(1)

def main():
    t1 = multiprocessing.Process(target=tes1)
    t2 = multiprocessing.Process(target=tes2)
    t1.start()
    t2.start()


if __name__ == '__main__':
    main()

3.使用队列实现进程间的通信（多功能之间进行解耦–进程之间资源不共享）

#进程之间的通信(全局变量不好使)--进程之间本来是独立的--用于进程功能之间进行解耦
import multiprocessing
import time
from  multiprocessing import Queue

def down_data(Q):
    """下载数据"""
    #模拟从网上下载的数据
    data = [11, 22, 33, 44]

    #向队列中写入数据
    for i in data:
        Q.put(i)

def analy_data(Q):
    """数据处理"""
    #从队列中获取数据
    waitting = list()
    while True:
        temp  = Q.get()
        waitting.append(temp)

        if Q.empty():
            break
    for i in waitting:
        print(i)

def main():
    #创建一个队列
    Q = Queue(10)

    #创建多个进程，将队列的引用当做实参传递到里面
    p1 = multiprocessing.Process(target=down_data, args=(Q, ))
    p2 = multiprocessing.Process(target=analy_data, args=(Q, ))
    p1.start()
    p2.start()

if __name__ == '__main__':
    main()

4.使用进程池最大化执行效率

• 当有多个任务时，我们不能给每一个任务都分配一个进程，那样会极大地造成系统数据和资源的冗余，所以使用进程池，分配一定数量的进程循环执行现有的任务

#进程池--程序的创建和销毁需要大量的时间，所以使用有限的进程数最大化使用效率
from multiprocessing import Pool
import time,random

def worker(i):
    t_start = time.time()
    print("开始执行%d" % i)
    time.sleep(random.random()*2)
    t_stop = time.time()
    print("执行完毕%d，执行时间为%f" % (i, t_stop-t_start))

def main():
    po = Pool(3) #创建进程池
    for i in range(10):
        po.apply_async(worker, (i,))#使用进程池中的进程

    po.close()#关闭进程池，进程池不在接收新的请求
    po.join()#使主进程等待子进程完成之后再关闭


if __name__ == '__main__':
    main()

5.多进程实现文件拷贝

• 使用了进程池最大化效率（需要自己摸索几个最合适）
• 使用了装饰器来计算执行时间
• 注意如果需要在进程池中的进程内与主进程实现数据通信时，所调用的队列的函数调用方法发生了改变（文中有写出）

#多进程的文件拷贝
import multiprocessing
from multiprocessing import  Pool
import time, os

#编写用于计算时间的装饰器
def time_use(func):
    print("开始计时")
    def call_func(*args, **kwargs):
        start = time.time()
        func(*args, **kwargs)
        finish = time.time()
        print("总执行时间为%f"  % (finish-start))
    return call_func


def copy_file(q, file_name, old_folder_name, new_folder_name ):#如果由进程池开辟的的子进程发生了异常，不会显示异常信息
    """完成文件的拷贝工作"""
    # print("从%s中拷贝%s到%s中：" % (old_folder_name, file_name, new_folder_name))
    with open(old_folder_name + "/" + file_name, "rb") as f1:
        temp = f1.read()
        # print(temp)
        with open(new_folder_name + "/" + file_name, "wb") as f2:
            f2.write(temp)
        #如果拷贝完了文件，就向队列中写入一个消息表示完成
        q.put(file_name)

@time_use
def main():
    #获取源文件夹名字
    old_folder_name = input("请输入要拷贝的文件夹的名字:")
    #创建新文件夹--不存在就创建，存在就啥也不干
    try:
        new_folder_name = old_folder_name + "复件"
        os.mkdir(new_folder_name)
    except:
        pass

    #获取文件夹中所有的文件名字
    file_names = os.listdir(old_folder_name)

    #创建进程池
    po = multiprocessing.Pool(3)

    #创建一个队列--用于统计完成的文件数
    q = multiprocessing.Manager().Queue() #想要让数据从进程池中放入就需要这种队列的定义方式


    #向进程池中添加copy文件的任务
    for file_name in file_names:
        po.apply_async(copy_file, args=(q, file_name, old_folder_name, new_folder_name))


    po.close()
    # po.join()
    all_num = len(file_names)
    temp = all_num
    while True:
        file_name = q.get()
        # print("已经完成copy%s" % file_name)
        temp -= 1
        print("拷贝剩余的进度为:%.2f%% " % (temp*100/all_num))#两个百分号显示一个百分号, \r返回行首
        if temp == 0:
            break
    print()


if __name__ == '__main__':
    main()