Django long exécution de tâches asynchrones avec threads / processing

Avertissement: je sais qu'il y a plusieurs questions similaires sur. Je pense que j'ai lu la plupart sinon la totalité d'entre eux, mais je n'ai pas trouvé de réponse à ma vraie question (Voir plus loin). Je sais aussi que l'utilisation de celery ou d'autres systèmes de file d'attente asynchrones est le meilleur moyen d'accomplir des tâches de longue durée - ou du moins d'utiliser un script géré par cron. Il y a aussi mod_wsgi doc sur les processus et les threads mais je ne suis pas sûr d'avoir tout compris.

la question Est:

quels sont les risques/problèmes liés à l'utilisation des solutions énumérées là-bas? Est l'un d'eux viable pour les tâches longues (ok, même si le céleri est mieux)? Ma question est vraiment plus sur la compréhension des internes de WSGI et python / django que sur la recherche de la meilleure solution globale. Problèmes de blocage des threads, accès non sécurisé aux variables, traitement des zombies, etc.

disons:

1. mon "long_process" fait quelque chose vraiment à l'abri. même si elle échoue, je n'ai pas de soins.
2. python >= 2.6
3. j'utilise mod_wsgi avec apache (est-ce que quelque chose va changer avec uwsgi ou gunicorn?) en mode démon

mod_wsgi conf:

WSGIDaemonProcess NAME user=www-data group=www-data threads=25
WSGIScriptAlias / /path/to/wsgi.py
WSGIProcessGroup %{ENV:VHOST}

j'ai pensé que ce sont les options disponibles pour le lancement de séparer (au sens large du terme) accomplir une tâche de longue haleine tout en répondant rapidement aux utilisateur:

os.fourche

import os

if os.fork()==0:
    long_process()
else:
    return HttpResponse()

sous-processus

import subprocess

p = subprocess.Popen([sys.executable, '/path/to/script.py'], 
                                    stdout=subprocess.PIPE, 
                                    stderr=subprocess.STDOUT)

(lorsque le script est susceptible d'être manage.py commande)

threads

import threading

t = threading.Thread(target=long_process,
                             args=args,
                             kwargs=kwargs)
t.setDaemon(True)
t.start()
return HttpResponse()

NB.

en raison du verrouillage global de L'interpréteur, dans CPython, un seul thread peut exécuter du code Python à la fois (même si certaines bibliothèques axées sur la performance peuvent surmonter cette limitation). Si vous souhaitez que votre application pour faire une meilleure utilisation de l'informatique ressources des machines multi-core, il vous est conseillé d'utiliser multiprocessing. Cependant, le threading est toujours un modèle approprié si vous voulez exécuter plusieurs tâches liées par des entrées/sorties simultanément.

le thread principal va rapidement revenir (le httpresponse). Est-ce que le bloc de thread long généré WSGI fera quelque chose d'autre pour une autre requête?!

multitraitement

from multiprocessing import Process

p = Process(target=_bulk_action,args=(action,objs))
p.start()
return HttpResponse()

ceci devrait résoudre la question de la simultanéité du fil, ne devrait pas il?

voilà donc les options auxquelles je pourrais penser. Ce qui peut fonctionner et ce n'est pas, et pourquoi?