import multiprocessing
queue = multiprocessing.Queue(隊列長度)

import multiprocessing
import time
def write_queue(queue):
  # 循環(huán)寫入數(shù)據(jù)
  for i in range(10):
    if queue.full():
      print("隊列已滿!")
      break
    # 向隊列中放入消息
    queue.put(i)
    print(i)
    time.sleep(0.5)
def read_queue(queue):
  # 循環(huán)讀取隊列消息
  while True:
    # 隊列為空，停止讀取
    if queue.empty():
      print("---隊列已空---")
      break
    # 讀取消息并輸出
    result = queue.get()
    print(result)
if __name__ == '__main__':
  # 創(chuàng)建消息隊列
  queue = multiprocessing.Queue(3)
  # 創(chuàng)建子進程
  p1 = multiprocessing.Process(target=write_queue, args=(queue,))
  p1.start()
  # 等待p1寫數(shù)據(jù)進程執(zhí)行結束后，再往下執(zhí)行
  p1.join()
  p1 = multiprocessing.Process(target=read_queue, args=(queue,))
  p1.start()

import multiprocessing
pool = multiprocessing.Pool(最大進程數(shù))

import multiprocessing 
Queue：queue = multiprocessing.Manager().Queue() 

import multiprocessing 
import time

def write_data(queue): 
# for循環(huán) 向消息隊列中寫入值 
for i in range(5): 
# 添加消息 
queue.put(i) 
print(i) 
time.sleep(0.2) 
print("隊列已滿~")

def read_data(queue):
  # 循環(huán)讀取數(shù)據(jù)
  while True:
    # 判斷隊列是否為空
    if queue.qsize() == 0:
      print("隊列為空～")
      break
    # 從隊列中讀取數(shù)據(jù)
    result = queue.get()
    print(result)
if __name__ == '__main__':
  # 創(chuàng)建進程池
  pool = multiprocessing.Pool(2)
  # 創(chuàng)建進程池隊列
  queue = multiprocessing.Manager().Queue()
  # 在進程池中的進程間進行通信
  # 使用線程池同步的方式，先寫后讀
  # pool.apply(write_data, (queue, ))
  # pool.apply(read_data, (queue, ))
  # apply_async() 返回ApplyResult 對象
  result = pool.apply_async(write_data, (queue, ))
  # ApplyResult對象的wait() 方法，表示后續(xù)進程必須等待當前進程執(zhí)行完再繼續(xù)
  result.wait()
  pool.apply_async(read_data, (queue, ))
  pool.close()
  # 異步后，主線程不再等待子進程執(zhí)行結束，再結束
  # join() 后，表示主線程會等待子進程執(zhí)行結束后，再結束
  pool.join()

# 導入模塊
import os
import multiprocessing
# 拷貝文件函數(shù)
def copy_dir(file_name, source_dir, desk_dir):
  # 要拷貝的文件路徑
  source_path = source_dir+'/'+file_name
  # 目標路徑
  desk_path = desk_dir+'/'+file_name
  # 獲取文件大小
  file_size = os.path.getsize(source_path)
  # 記錄拷貝次數(shù)
  i = 0
  # 以二進制度讀方式打開原文件
  with open(source_path, "rb") as source_file:
    # 以二進制寫入方式創(chuàng)建并打開目標文件
    with open(desk_path, "wb") as desk_file:
      # 循環(huán)寫入
      while True:
        # 讀取1024字節(jié)
        file_data = source_file.read(1024)
        # 如果讀到的不為空，則將讀到的寫入目標文件
        if file_data:
          desk_file.write(file_data)
          # 讀取次數(shù)+1
          i += 1
          # 拷貝百分比進度等于拷貝次數(shù)*1024*100/文件大小
          n = i*102400/file_size
          if n >= 100:
            n = 100
          print(file_name, "拷貝進度%.2f%%" % n)
        else:
          print(file_name, "拷貝成功")
          break
if __name__ == '__main__':
  # 要拷貝的文件夾
  source_dir = 'test'
  # 要拷貝到的路徑
  desk_dir = 'C:/Users/Administrator/Desktop/'+source_dir
  # 存在文件夾則不創(chuàng)建
  try:
    os.mkdir(desk_dir)
  except:
    print("目標文件夾已存在，未創(chuàng)建")
  # 獲取文件夾內文件目錄，存到列表里
  file_list = os.listdir(source_dir)
  print(file_list)
  # 創(chuàng)建進程池，最多同時運行3個子進程
  pool = multiprocessing.Pool(3)
  for file_name in file_list:
    # 異步方式添加到進程池內
    pool.apply_async(copy_dir, args=(file_name, source_dir, desk_dir))
  # 關閉進程池(停止添加，已添加的還可運行)
  pool.close()
  # 讓主進程阻塞，等待子進程結束
  pool.join()