python multithreading รอจนกว่าเธรดทั้งหมดจะเสร็จสิ้น

สิ่งนี้อาจถูกถามในบริบทที่คล้ายกัน แต่ฉันไม่สามารถหาคำตอบได้หลังจากค้นหาประมาณ 20 นาทีดังนั้นฉันจะถาม

ฉันได้เขียนสคริปต์ Python (สมมติว่า scriptA.py) และสคริปต์ (สมมติว่า scriptB.py)

ใน scriptB ฉันต้องการเรียก scriptA หลาย ๆ ครั้งด้วยอาร์กิวเมนต์ที่แตกต่างกันแต่ละครั้งจะใช้เวลาประมาณหนึ่งชั่วโมงในการรัน (มันเป็นสคริปต์ขนาดใหญ่ทำสิ่งต่างๆมากมาย .. ไม่ต้องกังวลกับมัน) และฉันต้องการที่จะสามารถเรียกใช้ scriptA พร้อมอาร์กิวเมนต์ที่แตกต่างกันทั้งหมดพร้อมกัน แต่ฉันต้องรอจนกว่าจะเสร็จสิ้นทั้งหมดก่อนที่จะดำเนินการต่อ รหัสของฉัน:

import subprocess

#setup
do_setup()

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

#finish
do_finish()

ฉันต้องการเรียกใช้ทั้งหมดsubprocess.call()ในเวลาเดียวกันจากนั้นรอจนกว่าทุกอย่างจะเสร็จสิ้นฉันจะทำอย่างไร

ฉันพยายามใช้เธรดดังตัวอย่างที่นี่ :

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()

แต่ฉันไม่คิดว่านี่จะถูกต้อง

ฉันจะรู้ได้อย่างไรว่าพวกเขาวิ่งเสร็จแล้วก่อนที่จะไปที่ฉันdo_finish()?

คุณต้องใช้วิธีการเข้าร่วมของThreadวัตถุในตอนท้ายของสคริปต์

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()

ดังนั้นหัวข้อหลักจะรอจนกว่าt1, t2และt3เสร็จสิ้นการดำเนินการ

ใส่เธรดในรายการจากนั้นใช้วิธีเข้าร่วม

 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()

ใน Python3 เนื่องจาก Python 3.2 มีวิธีการใหม่ในการเข้าถึงผลลัพธ์เดียวกันโดยส่วนตัวแล้วฉันชอบการสร้างเธรด / start / join แบบดั้งเดิมแพ็คเกจconcurrent.futures: https://docs.python.org/3/library/concurrent.futures .html

การใช้ThreadPoolExecutorรหัสจะเป็น:

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')

ผลลัพธ์ของรหัสก่อนหน้ามีลักษณะดังนี้:

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

ข้อดีอย่างหนึ่งคือคุณสามารถควบคุมการตั้งค่าปริมาณงานสูงสุดพร้อมกันได้

ฉันชอบใช้ความเข้าใจในรายการตามรายการอินพุต:

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]

คุณสามารถมีคลาสเช่นด้านล่างซึ่งคุณสามารถเพิ่ม 'n' จำนวนฟังก์ชันหรือ console_scripts ที่คุณต้องการดำเนินการด้วยความหลงใหลแบบคู่ขนานและเริ่มการดำเนินการและรอให้งานทั้งหมดเสร็จสิ้น ..

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()

จากthreading เอกสารประกอบโมดูล

มีวัตถุ "เธรดหลัก"; สิ่งนี้สอดคล้องกับเธรดเริ่มต้นของการควบคุมในโปรแกรม Python ไม่ใช่เธรด daemon

มีความเป็นไปได้ที่ "วัตถุด้ายหลอก" ถูกสร้างขึ้น นี่คือเธรดออบเจ็กต์ที่สอดคล้องกับ“ เธรดเอเลี่ยน” ซึ่งเป็นเธรดของการควบคุมที่เริ่มต้นนอกโมดูลเธรดเช่นโดยตรงจากโค้ด C วัตถุด้ายแบบจำลองมีฟังก์ชันการทำงานที่ จำกัด พวกมันมักจะถูกมองว่ามีชีวิตและไร้เดียงสาและไม่สามารถjoin()แก้ไขได้ พวกเขาจะไม่ถูกลบเนื่องจากเป็นไปไม่ได้ที่จะตรวจพบการสิ้นสุดของเธรดเอเลี่ยน

ดังนั้นหากต้องการจับสองกรณีนี้เมื่อคุณไม่สนใจที่จะเก็บรายชื่อเธรดที่คุณสร้างไว้:

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

ครั้นแล้ว:

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

อาจจะมีบางอย่างเช่น

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

ฉันเพิ่งเจอปัญหาเดียวกันที่ฉันต้องรอเธรดทั้งหมดที่สร้างขึ้นโดยใช้ for loop ฉันเพิ่งลองใช้โค้ดต่อไปนี้มันอาจไม่ใช่วิธีแก้ปัญหาที่สมบูรณ์แบบ แต่ฉันคิดว่ามันจะเป็นวิธีง่ายๆ ทดสอบ:

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