Python: Làm cách nào để chạy các hàm python song song?

Tôi đã nghiên cứu trước và không thể tìm ra câu trả lời cho câu hỏi của mình. Tôi đang cố gắng chạy song song nhiều hàm trong Python.

Tôi có một cái gì đó như thế này:

files.py

import common #common is a util class that handles all the IO stuff

dir1 = 'C:\folder1'
dir2 = 'C:\folder2'
filename = 'test.txt'
addFiles = [25, 5, 15, 35, 45, 25, 5, 15, 35, 45]

def func1():
   c = common.Common()
   for i in range(len(addFiles)):
       c.createFiles(addFiles[i], filename, dir1)
       c.getFiles(dir1)
       time.sleep(10)
       c.removeFiles(addFiles[i], dir1)
       c.getFiles(dir1)

def func2():
   c = common.Common()
   for i in range(len(addFiles)):
       c.createFiles(addFiles[i], filename, dir2)
       c.getFiles(dir2)
       time.sleep(10)
       c.removeFiles(addFiles[i], dir2)
       c.getFiles(dir2)

Tôi muốn gọi func1 và func2 và để chúng chạy cùng một lúc. Các chức năng không tương tác với nhau hoặc trên cùng một đối tượng. Ngay bây giờ tôi phải đợi func1 kết thúc trước khi func2 bắt đầu. Làm cách nào để thực hiện một số việc như dưới đây:

process.py

from files import func1, func2

runBothFunc(func1(), func2())

Tôi muốn có thể tạo cả hai thư mục khá gần cùng một lúc vì mỗi phút tôi đều đếm xem có bao nhiêu tệp đang được tạo. Nếu thư mục không có ở đó, nó sẽ làm mất thời gian của tôi.

Bạn có thể sử dụng threadinghoặc multiprocessing.

Do đặc thù của CPython , threadingkhông có khả năng đạt được tính song song thực sự. Vì lý do này, multiprocessingthường là một đặt cược tốt hơn.

Đây là một ví dụ đầy đủ:

from multiprocessing import Process

def func1():
  print 'func1: starting'
  for i in xrange(10000000): pass
  print 'func1: finishing'

def func2():
  print 'func2: starting'
  for i in xrange(10000000): pass
  print 'func2: finishing'

if __name__ == '__main__':
  p1 = Process(target=func1)
  p1.start()
  p2 = Process(target=func2)
  p2.start()
  p1.join()
  p2.join()

Cơ chế bắt đầu / tham gia các quy trình con có thể dễ dàng được gói gọn thành một hàm dọc theo dòng runBothFunc :

def runInParallel(*fns):
  proc = []
  for fn in fns:
    p = Process(target=fn)
    p.start()
    proc.append(p)
  for p in proc:
    p.join()

runInParallel(func1, func2)

Điều này có thể được thực hiện một cách thanh lịch với Ray , một hệ thống cho phép bạn dễ dàng song song hóa và phân phối mã Python của mình.

Để song song hóa ví dụ của bạn, bạn cần xác định các chức năng của mình với trình @ray.remotetrang trí, sau đó gọi chúng với .remote.

import ray

ray.init()

dir1 = 'C:\\folder1'
dir2 = 'C:\\folder2'
filename = 'test.txt'
addFiles = [25, 5, 15, 35, 45, 25, 5, 15, 35, 45]

# Define the functions. 
# You need to pass every global variable used by the function as an argument.
# This is needed because each remote function runs in a different process,
# and thus it does not have access to the global variables defined in 
# the current process.
@ray.remote
def func1(filename, addFiles, dir):
    # func1() code here...

@ray.remote
def func2(filename, addFiles, dir):
    # func2() code here...

# Start two tasks in the background and wait for them to finish.
ray.get([func1.remote(filename, addFiles, dir1), func2.remote(filename, addFiles, dir2)]) 

Nếu bạn truyền cùng một đối số cho cả hai hàm và đối số lớn, thì một cách hiệu quả hơn để thực hiện việc này là sử dụng ray.put(). Điều này tránh đối số lớn được tuần tự hóa hai lần và tạo hai bản sao bộ nhớ của nó:

largeData_id = ray.put(largeData)

ray.get([func1(largeData_id), func2(largeData_id)])

Nếu func1()và func2()trả về kết quả, bạn cần viết lại mã như sau:

ret_id1 = func1.remote(filename, addFiles, dir1)
ret_id2 = func1.remote(filename, addFiles, dir2)
ret1, ret2 = ray.get([ret_id1, ret_id2])

Có một số lợi thế khi sử dụng Ray so với mô-đun đa xử lý . Đặc biệt, cùng một đoạn mã sẽ chạy trên một máy cũng như trên một cụm máy. Để biết thêm ưu điểm của Ray, hãy xem bài đăng liên quan này .

Nếu các hàm của bạn chủ yếu thực hiện công việc I / O (và CPU ít hoạt động hơn) và bạn có Python 3.2+, bạn có thể sử dụng ThreadPoolExecutor :

from concurrent.futures import ThreadPoolExecutor

def run_io_tasks_in_parallel(tasks):
    with ThreadPoolExecutor() as executor:
        running_tasks = [executor.submit(task) for task in tasks]
        for running_task in running_tasks:
            running_task.result()

run_io_tasks_in_parallel([
    lambda: print('IO task 1 running!'),
    lambda: print('IO task 2 running!'),
])

Nếu các chức năng của bạn chủ yếu thực hiện công việc của CPU (và ít hoạt động I / O hơn) và bạn có Python 2.6+, bạn có thể sử dụng mô-đun đa xử lý :

from multiprocessing import Process

def run_cpu_tasks_in_parallel(tasks):
    running_tasks = [Process(target=task) for task in tasks]
    for running_task in running_tasks:
        running_task.start()
    for running_task in running_tasks:
        running_task.join()

run_cpu_tasks_in_parallel([
    lambda: print('CPU task 1 running!'),
    lambda: print('CPU task 2 running!'),
])

Nếu bạn là người dùng windows và đang sử dụng python 3, thì bài đăng này sẽ giúp bạn lập trình song song trong python. Khi bạn chạy chương trình gộp của thư viện đa xử lý thông thường, bạn sẽ gặp lỗi liên quan đến chức năng chính trong chương trình của mình. Điều này là do thực tế là các cửa sổ không có chức năng fork (). Bài viết dưới đây đưa ra giải pháp cho vấn đề được đề cập.

http://python.6.x6.nabble.com/Multiprocessing-Pool-woes-td5047050.html

Vì tôi đang sử dụng python 3, tôi đã thay đổi chương trình một chút như sau:

from types import FunctionType
import marshal

def _applicable(*args, **kwargs):
  name = kwargs['__pw_name']
  code = marshal.loads(kwargs['__pw_code'])
  gbls = globals() #gbls = marshal.loads(kwargs['__pw_gbls'])
  defs = marshal.loads(kwargs['__pw_defs'])
  clsr = marshal.loads(kwargs['__pw_clsr'])
  fdct = marshal.loads(kwargs['__pw_fdct'])
  func = FunctionType(code, gbls, name, defs, clsr)
  func.fdct = fdct
  del kwargs['__pw_name']
  del kwargs['__pw_code']
  del kwargs['__pw_defs']
  del kwargs['__pw_clsr']
  del kwargs['__pw_fdct']
  return func(*args, **kwargs)

def make_applicable(f, *args, **kwargs):
  if not isinstance(f, FunctionType): raise ValueError('argument must be a function')
  kwargs['__pw_name'] = f.__name__  # edited
  kwargs['__pw_code'] = marshal.dumps(f.__code__)   # edited
  kwargs['__pw_defs'] = marshal.dumps(f.__defaults__)  # edited
  kwargs['__pw_clsr'] = marshal.dumps(f.__closure__)  # edited
  kwargs['__pw_fdct'] = marshal.dumps(f.__dict__)   # edited
  return _applicable, args, kwargs

def _mappable(x):
  x,name,code,defs,clsr,fdct = x
  code = marshal.loads(code)
  gbls = globals() #gbls = marshal.loads(gbls)
  defs = marshal.loads(defs)
  clsr = marshal.loads(clsr)
  fdct = marshal.loads(fdct)
  func = FunctionType(code, gbls, name, defs, clsr)
  func.fdct = fdct
  return func(x)

def make_mappable(f, iterable):
  if not isinstance(f, FunctionType): raise ValueError('argument must be a function')
  name = f.__name__    # edited
  code = marshal.dumps(f.__code__)   # edited
  defs = marshal.dumps(f.__defaults__)  # edited
  clsr = marshal.dumps(f.__closure__)  # edited
  fdct = marshal.dumps(f.__dict__)  # edited
  return _mappable, ((i,name,code,defs,clsr,fdct) for i in iterable)

Sau chức năng này, mã vấn đề trên cũng được thay đổi một chút như sau:

from multiprocessing import Pool
from poolable import make_applicable, make_mappable

def cube(x):
  return x**3

if __name__ == "__main__":
  pool    = Pool(processes=2)
  results = [pool.apply_async(*make_applicable(cube,x)) for x in range(1,7)]
  print([result.get(timeout=10) for result in results])

Và tôi nhận được đầu ra là:

[1, 8, 27, 64, 125, 216]

Tôi nghĩ rằng bài đăng này có thể hữu ích cho một số người dùng windows.

Không có cách nào để đảm bảo rằng hai chức năng sẽ thực thi đồng bộ với nhau, điều này dường như là những gì bạn muốn làm.

Cách tốt nhất bạn có thể làm là chia chức năng thành nhiều bước, sau đó đợi cả hai kết thúc tại các điểm đồng bộ hóa quan trọng bằng cách sử dụng Process.join câu trả lời của @ aix đã đề cập.

Điều này tốt hơn là time.sleep(10)vì bạn không thể đảm bảo thời gian chính xác. Với việc chờ đợi rõ ràng, bạn đang nói rằng các chức năng phải được thực hiện xong khi thực hiện bước đó trước khi chuyển sang bước tiếp theo, thay vì giả sử nó sẽ được thực hiện trong vòng 10ms, điều này không được đảm bảo dựa trên những gì khác đang diễn ra trên máy.

Có vẻ như bạn có một hàm duy nhất mà bạn cần gọi trên hai tham số khác nhau. Điều này có thể được thực hiện một cách trang nhã bằng cách sử dụng kết hợp concurrent.futuresvà mapvới Python 3.2+

import time
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

def sleep_secs(seconds):
  time.sleep(seconds)
  print(f'{seconds} has been processed')

secs_list = [2,4, 6, 8, 10, 12]

Bây giờ, nếu hoạt động của bạn bị ràng buộc IO, thì bạn có thể sử dụng ThreadPoolExecutornhư sau:

with ThreadPoolExecutor() as executor:
  results = executor.map(sleep_secs, secs_list)

Lưu ý cách mapsử dụng ở đây đểmap hàm của bạn trong danh sách các đối số.

Bây giờ, nếu chức năng của bạn bị ràng buộc bởi CPU, thì bạn có thể sử dụng ProcessPoolExecutor

with ProcessPoolExecutor() as executor:
  results = executor.map(sleep_secs, secs_list)

Nếu bạn không chắc chắn, bạn chỉ cần thử cả hai và xem cái nào mang lại cho bạn kết quả tốt hơn.

Cuối cùng, nếu bạn đang muốn in ra kết quả của mình, bạn có thể chỉ cần thực hiện điều này:

with ThreadPoolExecutor() as executor:
  results = executor.map(sleep_secs, secs_list)
  for result in results:
    print(result)