twisted latente/Rückrufe und asynchronen Ausführung

Ich versuche, herauszufinden, wie kann ich meinen code mehr asynchrone twisted.

  • Eine Funktion gibt ein deferred-Objekt
  • dann füge ich eine Liste der Rückrufe
  • die erste callback-wird aufgerufen, nachdem die latente Funktion liefert ein Ergebnis durch deferred_obj.callback
  • dann, in der Kette von Rückrufen, der erste Rückruf wird noch was mit den Daten und rufen Sie die zweite callback -
  • und etc.

jedoch angekettet Rückrufe werden nicht als asynchrone, denn Sie sind angekettet und die Ereignis-Schleife wird feuern jeder von Ihnen gleichzeitig, bis es keine mehr, richtig?

Jedoch, wenn ich ein deferred-Objekt, und lege ich, wie seine Rückruf der deferred_obj.Rückruf als in d.addCallback(deferred_obj.callback) dann wird dies als asynchron, weil die deferred_obj wartet auf die Daten, und dann die Methode, die übergeben wird, werden die Daten warten auf Daten als auch, jedoch sobald ich d....callback '- d' - Objekt verarbeitet die Daten dann rufen Sie deferred_obj.callback-aber da dieses Objekt ist zurückgestellt, im Gegensatz zu dem Fall gefesselt Rückrufe, es wird asynchron... richtig?

Vorausgesetzt, alle mein code ist nicht-blockierend, das bedeutet, dass verkettet Rückrufe sind NICHT asynchron, während gekettet deferreds sind, richtig?

  • Bitte nehmen Sie sich diese und nutzen es in deinem wall of text: ...........
  • was auch immer das bedeutet :/
  • er meinte deine Frage ist sehr schwer zu Lesen, da es eine wall of text, so sollten Sie etwas mehr Platz...
  • Er meinte interpunction im Allgemeinen.
InformationsquelleAutor mayotic | 2010-12-27
  1. 8

    Rückrufe sind (standardmäßig) synchron. Jedoch, wie die Twisted-doc Punkte heraus:

    Wenn Sie brauchen, einer Latenten, um auf ein anderes warten, ist alles was Sie tun müssen, ist die Rückkehr eine Latente von einer Methode Hinzugefügt addCallbacks.

    So können Sie es verwenden, um einige der asynchronen Verarbeitung in Ihrer callback-Kette. Lassen Sie uns das tun:

    from twisted.internet import reactor, defer

def callback_func_2(result, previous_data):
    # here we pass the result of the deferred down the callback chain
    # (done synchronously)
    print "calling function 1 on result:%s with previous result:%s" % (result, previous_data)
    return result

def callback_func(result):
    #let's do some asynchronous stuff in this callback
    # simple trick here is to return a deferred from a callback 
    # instead of the result itself.
    # 
    # so we can do asynchronous stuff here, 
    # like firing something 1 second later and have 
    # another method processing the result
    print "calling function 1 on result:%s" % result
    d = defer.Deferred()
    reactor.callLater(1, d.callback, "second callback")
    d.addCallback(callback_func_2, result)
    return d

def do():
    d = defer.Deferred()
    reactor.callLater(1, d.callback, "first callback")
    d.addCallback(callback_func)
    return d

do()
reactor.run()
    • ja danke für das Beispiel, ich bin mit einem ähnlichen Modell wie die ein u dargestellt in meinem Programm
    InformationsquelleAutor Tommy
  2. 2

    Art, aber es gibt keine Parallelität in dieser Art von event processing. Keine neuen callback wird aufgerufen, bis der code wird wieder auf die Ereignis-Schleife. Also die Kette von Rückrufen ist synchron. Es ist nur asynchron in die event-Schleife.

    Dies ist ein Nachteil dieser Art der Programmierung, die Handler die meisten schnell ausführen, und sich wieder auf die Ereignis-Schleife so schnell wie möglich. Es sollte nicht eine zeitraubende Aufgabe in einem handler.

    • also, wenn deferred-Objekt eine Kette von Rückrufen, der code wird nicht wieder auf die Ereignis-Schleife, bis die ganze Kette übergeben wurde; allerdings, wenn ich eine Pause bis diese Kette Verwendung der zurückgestellten Gegenstände, die ich erlauben, den code zurück zu gehen, um die Ereignis-Schleife und überprüfen Sie für die anderen Veranstaltungen, die richtige?
    • Ja, genau. Das ist das Allgemeine Muster. Haben Sie vielleicht einführen Timer in der Ereignis-Schleife für die Verarbeitung von großen Datenmengen in einem Stück.
    • oi, ok, danke sehr 😀
    InformationsquelleAutor Keith
  3. 0

    Mit einer latenten macht nicht Ihr code asynchron.

    import time
from twisted.internet import defer
from twisted.internet import reactor

def blocking(duration, deferred):
    print "start blocking"
    time.sleep(duration)
    print "finished blocking"
    deferred.callback(True)

def other_task():
    print "working..."
    reactor.callLater(1, other_task)

def finish(result):
    print "stopping reactor in 2sec"
    reactor.callLater(2, reactor.stop)

def failed(reason):
    print reason
    print "stopping reactor in 2sec"
    reactor.callLater(2, reactor.stop)

def main():
    d = defer.Deferred()
    d.addCallbacks(finish, failed)
    reactor.callLater(0, blocking, 5, d)

if __name__ == "__main__":
    reactor.callLater(0, other_task)
    main()
    reactor.run()

    Wenn Sie über längere Zeit mit synchronous code, können Sie deferToThread oder brechen Sie in kurzen Iterationen mit einer Mitarbeiterin (verdreht.internet.Aufgabe)

    InformationsquelleAutor jlujan
  4. 0

    Wenn Sie möchten, um Ihren code mehr asynchron mit einem sauberen Ansatz dann schauen Sie sich dieses framework:

    https://github.com/iogf/untwisted

    Es hat ordentlich code mit verständlicher Dokumentation. Der Umgang mit asynchronen Modellen ist unkompliziert.

    InformationsquelleAutor Unknown Soldier
Schreibe einen Kommentar