Можно ли ждать завершения одновременно сразу нескольких потоков?

import threading
import time
 
def thread_function(i):
    time.sleep(i)
 
def main():
    threads = []
    for i in range(2):
        thread = threading.Thread(target=thread_function, args=(i))
        threads.append(thread)
 
    index_of_thread = wait_one_of_threads(threads) #  и wait_all_threads(threads)
 
    print(index_of_thread, "finished first...")
 
if __name__ == '__main__':
    main()

for i in threads:
    i.join()

import threading
import queue
import random
import time
 
 
def thread_function(i, q):
    time.sleep(random.randint(1, 5))
    q.put(i)
 
 
def main():
    q = queue.Queue()
    threads = []
    for i in range(2):
        thread = threading.Thread(target=thread_function, args=(i, q))
        threads.append(thread)
        thread.start()
 
    counter = 2
    while counter:
        i = q.get()
        print("#{} finished.".format(i))
        counter -= 1
 
    print("Done!")
 
 
if __name__ == '__main__':
    main()

import multiprocessing
import threading
import random
import time
 
def process_function(i, q):
    time.sleep(random.randint(1, 5))
    q.put(i)
 
 
def thread_function(n):
    q = multiprocessing.Queue()
    for i in range(n):
        process = multiprocessing.Process(target=process_function, args=(i, q))
        process.start()
 
    counter = n
    while counter:
        i = q.get()
        print("#{} finished.".format(i))
        counter -= 1
        # Послать сигнал с результатом в основной поток Qt эвент лупу !!!
 
def main():
    thread = threading.Thread(target=thread_function,args=(5,))
    thread.start()
    thread.join()
    print("Done!")
 
if __name__ == '__main__':
    main()

from concurrent.futures import ProcessPoolExecutor
import multiprocessing
import threading
import random
import time
from datetime import datetime
 
 
def process_function(i, q):
    time.sleep(random.randint(5, 20))
    q.put(i)
 
 
def thread_function(n):
    manager = multiprocessing.Manager()
    q = manager.Queue()
    # for i in range(n):
    #     process = multiprocessing.Process(target=process_function, args=(i, q))
    #     process.start()
 
    with ProcessPoolExecutor(max_workers=2) as executor:
        for i in range(n):
            executor.submit(process_function, i)
 
    counter = n
    while counter:
        i = q.get()
        print("{1} #{0} finished.".format(i, datetime.now().strftime('%H:%M:%S')))
        counter -= 1
    print("Done!")
 
 
def main():
    thread = threading.Thread(target=thread_function, args=(5,))
    thread.start()
    thread.join()
 
 
if __name__ == '__main__':
    main()

executor.submit(process_function, i, q)

import os
from concurrent.futures import ProcessPoolExecutor
import multiprocessing
import threading
import random
import time
from datetime import datetime
 
 
def process_function(i):
    delay = random.randint(5, 20)
    print("thread th id: {0}, pid: {1} value: {2} time: {3} delay: {4}"
          .format(threading.get_ident(), os.getppid(),
                  i,
                  datetime.now().strftime('%H:%M:%S'),
                  delay))
    time.sleep(delay)
    return i ** 2
 
def done_callback(future):
    print("callback th id: {0}, pid: {1} result: {2} time: {3}"
          .format(threading.get_ident(), os.getppid(),
                   future.result(), datetime.now().strftime('%H:%M:%S')))
 
 
def thread_function(n):
    print("creator th id: {0}, pid: {1}".format(threading.get_ident(), os.getppid()))
    with ProcessPoolExecutor(max_workers=2) as executor:
        for i in range(n):
            future = executor.submit(process_function, i)
            future.add_done_callback(done_callback)
 
 
def main():
    print("main th id: {0}, pid: {1}".format(threading.get_ident(),os.getppid()))
    thread = threading.Thread(target=thread_function, args=(5,))
    thread.start()
    thread.join()
 
 
if __name__ == '__main__':
    main()

from win32process import GetCurrentProcessId
GetCurrentProcessId()

 concurrent.futures.wait(fs, timeout=None, return_when=ALL_COMPLETED)