đa luồng python chờ cho đến khi tất cả các chủ đề kết thúc

Điều này có thể đã được hỏi trong một bối cảnh tương tự nhưng tôi không thể tìm thấy câu trả lời sau khoảng 20 phút tìm kiếm, vì vậy tôi sẽ hỏi.

Tôi đã viết một tập lệnh Python (giả sử: scriptA.py) và một tập lệnh (giả sử scriptB.py)

Trong scriptB tôi muốn gọi scriptA nhiều lần với các đối số khác nhau, mỗi lần mất khoảng một giờ để chạy, (đó là một kịch bản lớn, có rất nhiều thứ .. đừng lo lắng về điều đó) và tôi muốn có thể chạy scriptA với tất cả các đối số khác nhau cùng một lúc, nhưng tôi cần đợi cho đến khi TẤT CẢ chúng được thực hiện trước khi tiếp tục; mã của tôi:

import subprocess

#setup
do_setup()

#run scriptA
subprocess.call(scriptA + argumentsA)
subprocess.call(scriptA + argumentsB)
subprocess.call(scriptA + argumentsC)

#finish
do_finish()

Tôi muốn chạy tất cả subprocess.call()cùng một lúc, và sau đó đợi cho đến khi chúng hoàn thành, tôi nên làm điều này như thế nào?

Tôi đã cố gắng sử dụng luồng như ví dụ ở đây :

from threading import Thread
import subprocess

def call_script(args)
    subprocess.call(args)

#run scriptA   
t1 = Thread(target=call_script, args=(scriptA + argumentsA))
t2 = Thread(target=call_script, args=(scriptA + argumentsB))
t3 = Thread(target=call_script, args=(scriptA + argumentsC))
t1.start()
t2.start()
t3.start()

Nhưng tôi không nghĩ rằng điều này là đúng.

Làm thế nào để tôi biết họ đã chạy xong trước khi đến nhà tôi do_finish()?

Bạn cần sử dụng phương thức nối của Threadđối tượng vào cuối đoạn script.

t1 = Thread(target=call_script, args=(scriptA + argumentsA))
t2 = Thread(target=call_script, args=(scriptA + argumentsB))
t3 = Thread(target=call_script, args=(scriptA + argumentsC))

t1.start()
t2.start()
t3.start()

t1.join()
t2.join()
t3.join()

Do đó, chủ đề chính sẽ chờ đến t1,t2 và t3kết thúc thực hiện.

Đặt các chủ đề trong một danh sách và sau đó sử dụng phương thức Tham gia

 threads = []

 t = Thread(...)
 threads.append(t)

 ...repeat as often as necessary...

 # Start all threads
 for x in threads:
     x.start()

 # Wait for all of them to finish
 for x in threads:
     x.join()

Trong Python3, vì Python 3.2 có một cách tiếp cận mới để đạt được kết quả tương tự, mà cá nhân tôi thích cách tạo / bắt đầu / tham gia truyền thống, gói concurrent.futures: https://docs.python.org/3/l Library / conản.futures .html

Sử dụng ThreadPoolExecutormã sẽ là:

from concurrent.futures.thread import ThreadPoolExecutor
import time

def call_script(ordinal, arg):
    print('Thread', ordinal, 'argument:', arg)
    time.sleep(2)
    print('Thread', ordinal, 'Finished')

args = ['argumentsA', 'argumentsB', 'argumentsC']

with ThreadPoolExecutor(max_workers=2) as executor:
    ordinal = 1
    for arg in args:
        executor.submit(call_script, ordinal, arg)
        ordinal += 1
print('All tasks has been finished')

Đầu ra của mã trước đó là một cái gì đó như:

Thread 1 argument: argumentsA
Thread 2 argument: argumentsB
Thread 1 Finished
Thread 2 Finished
Thread 3 argument: argumentsC
Thread 3 Finished
All tasks has been finished

Một trong những lợi thế là bạn có thể kiểm soát thông lượng cài đặt các công nhân đồng thời tối đa.

Tôi thích sử dụng hiểu danh sách dựa trên danh sách đầu vào:

inputs = [scriptA + argumentsA, scriptA + argumentsB, ...]
threads = [Thread(target=call_script, args=(i)) for i in inputs]
[t.start() for t in threads]
[t.join() for t in threads]

Bạn có thể có một lớp nào đó như bên dưới mà từ đó bạn có thể thêm số lượng hàm hoặc bảng điều khiển bạn muốn thực hiện trong niềm đam mê song song và bắt đầu thực hiện và chờ cho tất cả các công việc hoàn thành ..

from multiprocessing import Process

class ProcessParallel(object):
    """
    To Process the  functions parallely

    """    
    def __init__(self, *jobs):
        """
        """
        self.jobs = jobs
        self.processes = []

    def fork_processes(self):
        """
        Creates the process objects for given function deligates
        """
        for job in self.jobs:
            proc  = Process(target=job)
            self.processes.append(proc)

    def start_all(self):
        """
        Starts the functions process all together.
        """
        for proc in self.processes:
            proc.start()

    def join_all(self):
        """
        Waits untill all the functions executed.
        """
        for proc in self.processes:
            proc.join()


def two_sum(a=2, b=2):
    return a + b

def multiply(a=2, b=2):
    return a * b


#How to run:
if __name__ == '__main__':
    #note: two_sum, multiply can be replace with any python console scripts which
    #you wanted to run parallel..
    procs =  ProcessParallel(two_sum, multiply)
    #Add all the process in list
    procs.fork_processes()
    #starts  process execution 
    procs.start_all()
    #wait until all the process got executed
    procs.join_all()

Từ threading tài liệu mô-đun

Có một đối tượng chủ đề chính của người Viking; cái này tương ứng với luồng điều khiển ban đầu trong chương trình Python. Nó không phải là một chủ đề daemon.

Có khả năng các đối tượng chủ đề giả hình tinh tinh được tạo ra. Đây là các đối tượng luồng tương ứng với các luồng ngoài hành tinh của người Viking, là các luồng điều khiển được bắt đầu bên ngoài mô-đun luồng, chẳng hạn như trực tiếp từ mã C. Đối tượng chủ đề giả có chức năng hạn chế; chúng luôn được coi là còn sống và daemon, và không thể được chỉnh sửa join(). Chúng không bao giờ bị xóa, vì không thể phát hiện sự chấm dứt của các chủ đề ngoài hành tinh.

Vì vậy, để nắm bắt hai trường hợp đó khi bạn không quan tâm đến việc giữ một danh sách các chủ đề bạn tạo:

import threading as thrd


def alter_data(data, index):
    data[index] *= 2


data = [0, 2, 6, 20]

for i, value in enumerate(data):
    thrd.Thread(target=alter_data, args=[data, i]).start()

for thread in thrd.enumerate():
    if thread.daemon:
        continue
    try:
        thread.join()
    except RuntimeError as err:
        if 'cannot join current thread' in err.args[0]:
            # catchs main thread
            continue
        else:
            raise

Trong đó:

>>> print(data)
[0, 4, 12, 40]

Có lẽ, một cái gì đó như

for t in threading.enumerate():
    if t.daemon:
        t.join()

Tôi vừa gặp một vấn đề tương tự khi tôi cần đợi tất cả các luồng được tạo bằng vòng lặp for. Tôi chỉ thử đoạn mã sau. Đây có thể không phải là giải pháp hoàn hảo nhưng tôi nghĩ đó sẽ là một giải pháp đơn giản để kiểm tra:

for t in threading.enumerate():
    try:
        t.join()
    except RuntimeError as err:
        if 'cannot join current thread' in err:
            continue
        else:
            raise