Ausführen von Python-Funktion im Haupt-Thread von Aufruf in Dummy-Thread

Question

Ich habe ein Python-Skript, das asynchrone Rückrufe von .NET Remoting behandelt. Diese Rückrufe werden in einem Dummy-Thread (Worker) ausgeführt. In meinem Callback-Handler muss ich eine Funktion aufrufen, die ich in meinem Skript definiert habe, aber ich muss die Funktion im Hauptthread ausführen.

Der Haupt-Thread ist ein Remote-Client, der Befehle an einen Server sendet. Einige dieser Befehle führen zu asynchronen Rückrufen.

Grundsätzlich brauche ich das Äquivalent von .NETs Invoke-Methode. Ist das möglich?

Answer 1

Sie möchten die Klasse Queue verwenden, um eine Warteschlange einzurichten, die Ihre Dummy-Threads mit Funktionen füllen und die Ihr Hauptthread belegt.

import Queue 

#somewhere accessible to both: 
callback_queue = Queue.Queue() 

def from_dummy_thread(func_to_call_from_main_thread): 
    callback_queue.put(func_to_call_from_main_thread) 

def from_main_thread_blocking(): 
    callback = callback_queue.get() #blocks until an item is available 
    callback() 

def from_main_thread_nonblocking(): 
    while True: 
     try: 
      callback = callback_queue.get(False) #doesn't block 
     except Queue.Empty: #raised when queue is empty 
      break 
     callback() 

Demo:

import threading 
import time 

def print_num(dummyid, n): 
    print "From %s: %d" % (dummyid, n) 
def dummy_run(dummyid): 
    for i in xrange(5): 
     from_dummy_thread(lambda: print_num(dummyid, i)) 
     time.sleep(0.5) 

threading.Thread(target=dummy_run, args=("a",)).start() 
threading.Thread(target=dummy_run, args=("b",)).start() 

while True: 
    from_main_thread_blocking() 

Drucke:

From a: 0 
From b: 0 
From a: 1 
From b: 1 
From b: 2 
From a: 2 
From b: 3 
From a: 3 
From b: 4 
From a: 4 

und blockiert dann für immer