implémentant un processus de file d'attente/fil de base dans python

Question

cherchant des globes oculaires pour vérifier que le morceau suivant de python python a du sens. Je cherche à engendrer un certain nombre de threads pour implémenter certaines fonctions inproc aussi vite que possible. l'idée est de reproduire les fils dans la boucle principale, de sorte que l'application va exécuter les threads simultanément d'une manière parallèle/simultanée

chunk of code 
-get the filenames from a dir 
-write each filename ot a queue 
-spawn a thread for each filename, where each thread 
    waits/reads value/data from the queue 
-the threadParse function then handles the actual processing 
    based on the file that's included via the "execfile" function... 


# System modules 
from Queue import Queue 
from threading import Thread 
import time 

# Local modules 
#import feedparser 

# Set up some global variables 
appqueue = Queue() 

# more than the app will need 
# this matches the number of files that will ever be in the 
# urldir 
# 
num_fetch_threads = 200 


def threadParse(q) 
    #decompose the packet to get the various elements 
    line = q.get() 
    college,level,packet=decompose (line) 

    #build name of included file 
    fname=college+"_"+level+"_Parse.py" 
    execfile(fname) 
    q.task_done() 


#setup the master loop 
while True 
    time.sleep(2) 
    # get the files from the dir 
    # setup threads 
    filelist="ls /urldir" 
    if filelist 
    foreach file_ in filelist: 
     worker = Thread(target=threadParse, args=(appqueue,)) 
     worker.start() 

    # again, get the files from the dir 
    #setup the queue 
    filelist="ls /urldir" 
    foreach file_ in filelist: 
     #stuff the filename in the queue 
     appqueue.put(file_) 


    # Now wait for the queue to be empty, indicating that we have 
    # processed all of the downloads. 

    #don't care about this part 

    #print '*** Main thread waiting' 
    #appqueue.join() 
    #print '*** Done' 

Pensées/commentaires/pointeurs sont appréciés ...

grâce

Answer 1

Si je comprends bien ce principe: Vous créez beaucoup de threads pour que les choses se fassent plus rapidement. Cela ne fonctionne que si la partie principale du travail effectué dans chaque thread est effectuée sans tenir le GIL. Donc, s'il y a beaucoup d'attente pour les données du réseau, du disque ou quelque chose comme ça, ce pourrait être une bonne idée. Si chacune des tâches utilise beaucoup de CPU, cela fonctionnera comme sur une machine monoprocesseur à un processeur et vous pourriez aussi bien les faire en séquence.

Je dois ajouter que ce que j'ai écrit est vrai pour CPython, mais pas nécessairement pour Jython/IronPython. En outre, je devrais ajouter que si vous avez besoin d'utiliser plus de processeurs/cœurs, il y a le module multiprocessing qui pourrait aider.