J'essaie donc de comparer si le threading est plus rapide ou le multitraitement . En théorie, grâce à GIL , le multitraitement devrait être plus rapide que le multithreading car un seul thread s'exécute à la fois. Mais j'obtiens des résultats opposés , c'est-à-dire que le threading prend moins de temps que le multitraitement, ce qui me manque, aidez-moi.

Ci-dessous le code du filetage

import threading
from queue import Queue
import time

print_lock = threading.Lock()

def exampleJob(worker):
    time.sleep(10)  
    with print_lock:
        print(threading.current_thread().name,worker)


def threader():
    while True:

        worker = q.get()


        exampleJob(worker)


        q.task_done()

q = Queue()

for x in range(4):
     t = threading.Thread(target=threader)

     print(x)
     t.daemon = True


     t.start()

start = time.time()


for worker in range(8):
    q.put(worker)


q.join()


print('Entire job took:',time.time() - start)

Vous trouverez ci-dessous le code du multitraitement

import multiprocessing as mp
import time

def exampleJob(print_lock,worker):                 # function simulating some computation
    time.sleep(10)
    with print_lock:
        print(mp.current_process().name,worker)

def processor(print_lock,q):                       # function where process pick up the job
    while True:
        worker = q.get()
        if worker is None: # flag to exit the process
            break
        exampleJob(print_lock,worker)


if __name__ == '__main__':

    print_lock = mp.Lock()
    q = mp.Queue()
    processes = [mp.Process(target=processor,args=(print_lock,q)) for _ in range(4)]

    for process in processes:
        process.start()    

    start = time.time()
    for worker in range(8):
        q.put(worker)

    for process in processes:
        q.put(None) # quit indicator

    for process in processes:
        process.join()

    print('Entire job took:',time.time() - start)

1
louis philippe 12 avril 2020 à 09:53

2 réponses

Meilleure réponse

L'ajout à @zmbq threading ne sera plus lent que lorsque vous effectuez une tâche intensive en calcul en raison de la présence de GIL. Si vos opérations sont liées aux E / S et peu d'autres opérations similaires, le threading sera certainement plus rapide car il y a moins de frais généraux impliqués. Veuillez vous référer au blog suivant pour une meilleure compréhension de la même chose.

Exploiter le multitraitement et le multithreading en Python en tant que Data Scientist

J'espère que cela t'aides!

0
Parthasarathy Subburaj 12 avril 2020 à 07:06

Ce n'est pas un bon test. time.sleep n'acquiert probablement pas le GIL, vous exécutez donc des threads simultanés plutôt que des processus concurrents. Les threads sont plus rapides car il n'y a pas de frais de démarrage.

Vous devriez effectuer quelques calculs dans vos threads, vous verrez alors la différence.

1
zmbq 12 avril 2020 à 06:59