À l'aide de gevent monkey patching avec filetage, fait de fil de travail en série

Je suis en utilisant gevent et je suis monkey patching tout.

Il semble que le monkey patching causes les threads de travail en série.

Mon code:

import threading
from gevent import monkey; monkey.patch_all()

class ExampleThread(threading.Thread):
    def run(self):
        do_stuff()  # takes a few minutes to finish
        print 'finished working'

if __name__ == '__main__':
    worker = ExampleThread()
    worker.start()
    print 'this should be printed before the worker finished'

De sorte que le fil ne fonctionne pas comme prévu.

Mais si je supprime le monkey.patch_all() il fonctionne très bien.

Le problème est que j'ai besoin de la monkey.patch_all() pour l'utilisation de gevent (maintenant indiqué dans le code ci-dessus)

Ma solution:

J'ai changé le 

monkey.patch_all()

à 

monkey.patch_all(thread=False)

donc je ne suis pas patcher le fil.

InformationsquelleAutor yossi | 2012-02-08
  1. 26

    Quand les fils sont de singe patché en gevent, ils se comportent comme des coroutines. Cela signifie que vous devez explicitement le contrôle du rendement pour le rendre possible pour les autres coroutines à exécuter.

    La façon de le faire est d'appeler une opération de blocage qui a été patché (cela donnera automatiquement) ou gevent.le sommeil:

    #!/usr/bin/env python
from gevent import monkey, sleep
monkey.patch_all()
import threading

class ExampleThread(threading.Thread):
    def run(self):
        for i in xrange(10):
            print 'working'
            sleep()

if __name__ == '__main__':
    worker = ExampleThread()
    worker.start()
    print 'this will be printed after the first call to sleep'
    • j'ai édité ma question. je ne peux pas utiliser le sommeil, parce que mon travail prend que quelques minutes,
    • Si vous avez une tâche qui prend du temps et n'est pas possible de céder le contrôle à un certain point, alors vous devez véritable threads au lieu de coroutines. Dans ce cas, je dirais que vous êtes mieux de ne pas patcher les threads.
    • ok, ce que j'ai fait est le singe.patch_all(thread=False)
    • J'ai trouvé cela intéressant. Ce serait le cas d'utilisation de ce rapport à la norme theading module.
    • La motivation de la section de PEP342 peut-être une bonne source pour cela. En résumé, les threads ne sont pas vraiment bon marché, et si nous avons besoin de beaucoup d'entre eux, alors il est utile de considérer des solutions de rechange.
    InformationsquelleAutor jcollado
  2. 0

    Vous pouvez laisser votre Fil à base de classe à la place si vous remplacez la Thread avec Greenlet, par exemple comme ceci:

    from gevent import monkey
from gevent import Greenlet
from threading import Thread


class ThreadLikeGreenlet(Greenlet):
    def __init__(self, name=None, target=None, args=(), kwargs=()):
        super().__init__(target, *args, **dict(kwargs))
        self.name = name

def is_gevent_patched():
    return monkey.is_module_patched('threading')

if is_gevent_patched():
    Thread = ThreadLikeGreenlet  # substitute Thread with Greenlet

class ExampleThread(Thread):
    ...

    il fonctionne comme vous le souhaitez puis.

    • comment l'utiliser?
    InformationsquelleAutor Bob