多任务—进程

 from multiprocessing import Queue
 
 
 q = Queue(3)    # 初始哈Queue对象，最多可接手3条put
 q.put(1)
 q.put(2)
 print(q.full())   # False
 q.put(3)
 print(q.full())   # True
 
 
 #因为消息列队已满下面的try都会抛出异常，第一个try会等待2秒后再抛出异常，第二个Try会立刻抛出异常
 try:
     q.put(4, True, 2)
 except:
     print("消息队列已满：现有消息数量%s" % q.qsize())
 
 try:
     q.put_nowait(4)
 except:
     print("消息队列已满：现有消息数量%s" % q.qsize())
 
 #推荐的方式，先判断消息列队是否已满，再写入
 if not q.full():
     q.put_nowait(4)
 
 #读取消息时，先判断消息列队是否为空，再读取
 if not q.empty():
     for i in range(q.qsize()):
         print(q.get_nowait())
                                              

 from multiprocessing import Process, Queue
 import time,random
 
 
 # 写数据进程执行的代码:
 def write(q):
     for i in range(3):
         print("puting %d in queue" % i)
         q.put(i)
         time.sleep(random.random())
 
 
 def read(q):
     while True:
         if not q.empty():
             print("%i reading in queue" % q.get(True))
             time.sleep(random.random())
         else:
             break
 
 if __name__ == "__main__":
     q = Queue()
     wp = Process(target=write, args=(q,))
     rp = Process(target=read, args=(q,))
 
     wp.start()   # 启动子进程wq，写入:
     wp.join()    # 等待pw结束:
 
     rp.start()
     rp.join()
     print('所有数据都写入并且读完')

 from multiprocessing import Process, Pool
 import time, os, random
 
 
 def func(num):
     start_time = time.time()
     print("%d开始执行，进程号%s" %(num,os.getpid()))
     time.sleep(random.random())
     end_time = time.time()
     print("%d执行完毕，耗时%0.2f" % (num,end_time-start_time))
 
 
 po = Pool(3)
 for i in range(10):
     # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
     # 每次循环将会用空闲出来的子进程去调用目标
     po.apply_async(func, (i,))
 
 print("--start--")
 po.close()   # 关闭进程池，关闭后po不再接收新的请求
 po.join()   # 等待po中所有子进程执行完成，必须放在close语句之后
 print("--end--")


# 执行结果：
--start--
0开始执行，进程号4333
1开始执行，进程号4334
2开始执行，进程号4332
0执行完毕，耗时0.65
3开始执行，进程号4333
1执行完毕，耗时0.85
4开始执行，进程号4334
2执行完毕，耗时0.95
5开始执行，进程号4332
4执行完毕，耗时0.43
6开始执行，进程号4334
5执行完毕，耗时0.41
7开始执行，进程号4332
3执行完毕，耗时0.85
8开始执行，进程号4333
6执行完毕，耗时0.51
9开始执行，进程号4334
9执行完毕，耗时0.24
8执行完毕，耗时0.54
7执行完毕，耗时0.75
--end--

 from multiprocessing import Manager, Pool
 import os, time, random
 
 
 def write(q):
     print("write启动(%s),父进程(%s)" % (os.getpid(), os.getppid()))
     for i in range(3):
         q.put(i)
 
 def read(q):
     print("read启动(%s), 父进程(%s)" % (os.getpid(), os.getppid()))
     for i in range(q.qsize()):
         print("正在从队列读取消息%d" % q.get())
 
 if __name__ == "__main__":
     print("start:%s" % os.getpid())
     q = Manager().Queue()
     po = Pool()
     po.apply_async(write, (q,))
     time.sleep(1)   # 先让上面的任务向Queue存入数据，然后再让下面的任务开始从中取数据
 
     po.apply_async(read, (q,))
 
     po.close()
     po.join()
     print("end:%s" % os.getpid())

# 执行结果：
start:4586
write启动(4592),父进程(4586)
read启动(4592), 父进程(4586)
正在从队列读取消息0
正在从队列读取消息1
正在从队列读取消息2
end:4586

 import multiprocessing, time, os, random
 
 
 def copy_file(queue, file_name, need_copy_file, new_file):
     f_read = open(need_copy_file + '/' + file_name, 'rb')
     f_write = open(new_file + '/' + file_name, 'wb')
     while True:
         time.sleep(random.random())
         content = f_read.read()
         if content:
             f_write.write(content)
         else:
             break
     f_read.close()
     f_write.close()
     # 发送已经拷贝完毕的文件名字
     queue.put(file_name)
 
 
 if __name__ == "__main__":
 
     # 获取想要copy的文件夹
     need_copy_file = input("输入文件名:")
     # 新的文件夹名称
     new_file = need_copy_file + "[副本]"
     # 创建目标文件夹
     try:
         os.mkdir(new_file)
     except:
         print("创建文件失败")
     # 获取这个文件夹中所有的普通文件名
     file_names = os.listdir(need_copy_file)
 
     # 创建队列
     queue = multiprocessing.Manager().Queue()
     # 创建进程池
     pool = multiprocessing.Pool(3)
     # 向进程池中添加任务
     for file_name in file_names:
         pool.apply_async(copy_file, (queue, file_name, need_copy_file, new_file))
     pool.close()
     # 主进程显示进度
     all_file_nums = len(file_names)
     while True:
         file_name = queue.get()
         if file_name in file_names:
             file_names.remove(file_name)
         copy_rate = (all_file_nums - len(file_names))*100/all_file_nums
         print("\r%.2f...(%s)" % (copy_rate, file_name) + " "*50, end="")
         if copy_rate >= 100:
             print("\ncopy完成")
             break