İş parçacığından döndürülen değeri döndürür

Question

Seçimi geri almak için bir parçacığı veya herhangi bir değeri Python'daki ana öğeye geri nasıl gönderirim?

Answer 1

Sana parçacığı başlamadan önce Queue.Queue örneğini ve parçacığının args biri olarak geçmesi öneririm. Ebeveyn, istediği zaman .get veya .get_nowait yapabilir.

Kuyruklar genellikle Python iplik senkronizasyonu ve iletişimi düzenlemek için en iyi yoldur: bunlar özünde evreli, ileti geçirme araçları konum - genel olarak çoklu görev düzenlemenin en iyi yolu -)

Answer 2

Python iş parçacığı modülünde, kilitlerle ilişkili durum nesneleri vardır. Bir yöntem acquire(), temel alınan yöntemden hangi değer döndürülürse döndürülür. Daha fazla bilgi için: bir argüman olarak alınan sıraya iplik bitmeden, bu .put s sonucu: Python Condition Objects

Answer 3

başka bir yaklaşım! iş parçacığına bir geriçağırım işlevini iletmektir. Bu, her zaman yeni iş parçacığından, üst öğeye değer döndürmek için basit, güvenli ve esnek bir yol sağlar.

# A sample implementation 

import threading 
import time 

class MyThread(threading.Thread): 
    def __init__(self, cb): 
     threading.Thread.__init__(self) 
     self.callback = cb 

    def run(self): 
     for i in range(10): 
      self.callback(i) 
      time.sleep(1) 


# test 

import sys 

def count(x): 
    print x 
    sys.stdout.flush() 

t = MyThread(count) 
t.start() 

Answer 4

tamamlamak iplik beklemek() katılmak çağırarak olsaydı, sadece Konu örneğine kendisine sonucunu eklemenizi ve daha sonra katılmak() döndükten sonra ana iş parçacığı çağırın.

Diğer taraftan, iş parçacığının yapıldığını ve sonucun kullanılabilir olduğunu nasıl anlamaya niyetlendiğinizi bize söylemezsiniz. Eğer bunu zaten yapmanın bir yolu varsa, muhtemelen (ve eğer bize söyleseydiniz) sonuçları elde etmenin en iyi yoluna işaret edecektir.

Answer 5

Bir Kuyruk örneğini parametre olarak iletmeniz gerekir, ardından döndürme nesnesini sıraya sığdırmalısınız. Verdiğiniz değeri, queue.get() ile gönderebilirsiniz.

Örnek: birden çok iş parçacığı için

queue = Queue.Queue() 
thread_ = threading.Thread(
       target=target_method, 
       name="Thread1", 
       args=[params, queue], 
       ) 
thread_.start() 
thread_.join() 
queue.get() 

def target_method(self, params, queue): 
""" 
Some operations right here 
""" 
your_return = "Whatever your object is" 
queue.put(your_return) 

Kullanım:

#Start all threads in thread pool 
    for thread in pool: 
     thread.start() 
     response = queue.get() 
     thread_results.append(response) 

#Kill all threads 
    for thread in pool: 
     thread.join() 

bu uygulamayı kullanır ve bu benim için iyi çalışıyor. Keşke yapmanı diliyorum.

Answer 6

Kullanım lambda hedef iplik fonksiyonunu sarın ve bir kuyruğunu kullanarak ana konuya geri dönüş değerini geçmesi. (Orijinal hedef fonksiyonu ekstra kuyruk parametresi olmadan değişmez.)

örnek kod:

import threading 
import queue 
def dosomething(param): 
    return param * 2 
que = queue.Queue() 
thr = threading.Thread(target = lambda q, arg : q.put(dosomething(arg)), args = (que, 2)) 
thr.start() 
thr.join() 
while not que.empty(): 
    print(que.get()) 

Çıktı:

4 

Answer 7

POC: Sen queue senkronize kullanabilirsiniz

import random 
import threading 

class myThread(threading.Thread): 
    def __init__(self, arr): 
     threading.Thread.__init__(self) 
     self.arr = arr 
     self.ret = None 

    def run(self): 
     self.myJob(self.arr) 

    def join(self): 
     threading.Thread.join(self) 
     return self.ret 

    def myJob(self, arr): 
     self.ret = sorted(self.arr) 
     return 

#Call the main method if run from the command line. 
if __name__ == '__main__': 
    N = 100 

    arr = [ random.randint(0, 100) for x in range(N) ] 
    th = myThread(arr) 
    th.start() 
    sortedArr = th.join() 

    print "arr2: ", sortedArr 

Answer 8

modülü.

def check_infos(user_id, queue): 
    result = send_data(user_id) 
    queue.put(result) 

Şimdi böyle verilerinizi alabilirsiniz:

import queue, threading 
queued_request = queue.Queue() 
check_infos_thread = threading.Thread(target=check_infos, args=(user_id, queued_request)) 
check_infos_thread.start() 
final_result = queued_request.get() 

Answer 9

Sürpriz kimse bunu sen tekini söz olduğum
Eğer bilinen bir kimliğe sahip veritabanından bir kullanıcı bilgilerinizi kontrol gerekir düşünün Belki de bunun habersiz olduğum başlıca sorunları vardır.

Answer 10

Aşağıdaki sarma işlevi, varolan bir işlevi saracak ve her ikisini de işaret eden bir nesneyi döndürecektir (böylece start(), join(), vb .'yi arayabilmeniz için) ve aynı zamanda nihai dönüş değerini görüntüleme/görüntüleme.

def threadwrap(func,args,kwargs): 
    class res(object): result=None 
    def inner(*args,**kwargs): 
    res.result=func(*args,**kwargs) 
    import threading 
    t = threading.Thread(target=inner,args=args,kwargs=kwargs) 
    res.thread=t 
    return res 

def myFun(v,debug=False): 
    import time 
    if debug: print "Debug mode ON" 
    time.sleep(5) 
    return v*2 

x=threadwrap(myFun,[11],{"debug":True}) 
x.thread.start() 
x.thread.join() 
print x.result 

Tamam görünüyor ve threading.Thread sınıf kolayca işlevselliği bu tür (*) uzatılabilir görünüyor, bu yüzden zaten orada değil neden merak ediyorum. Yukarıdaki yöntemle bir kusur var mı?

(*) Bu soru için husanu'nun cevabının tam olarak threading.Thread alt sınıfını, join() döndürme değerini verdiği bir sürümle sonuçlandığını unutmayın.

Answer 11

jcomeau_ictx'ın önerisine dayanmaktadır. Karşılaştığım en basit olanı. Buradaki gereksinim, sunucuda çalışan üç farklı işlemden çıkış durumu statüsünü almak ve üçünün de başarılı olması durumunda başka bir komut dosyasını tetiklemekti. Bu

class myThread(threading.Thread): 
     def __init__(self,threadID,pipePath,resDict): 
      threading.Thread.__init__(self) 
      self.threadID=threadID 
      self.pipePath=pipePath 
      self.resDict=resDict 

     def run(self): 
      print "Starting thread %s " % (self.threadID) 
      if not os.path.exists(self.pipePath): 
      os.mkfifo(self.pipePath) 
      pipe_fd = os.open(self.pipePath, os.O_RDWR | os.O_NONBLOCK) 
      with os.fdopen(pipe_fd) as pipe: 
       while True: 
        try: 
        message = pipe.read() 
        if message: 
         print "Received: '%s'" % message 
         self.resDict['success']=message 
         break 
        except: 
         pass 

    tResSer={'success':'0'} 
    tResWeb={'success':'0'} 
    tResUisvc={'success':'0'} 


    threads = [] 

    pipePathSer='/tmp/path1' 
    pipePathWeb='/tmp/path2' 
    pipePathUisvc='/tmp/path3' 

    th1=myThread(1,pipePathSer,tResSer) 
    th2=myThread(2,pipePathWeb,tResWeb) 
    th3=myThread(3,pipePathUisvc,tResUisvc) 

    th1.start() 
    th2.start() 
    th3.start() 

    threads.append(th1) 
    threads.append(th2) 
    threads.append(th3) 

    for t in threads: 
     print t.join() 

    print "Res: tResSer %s tResWeb %s tResUisvc %s" % (tResSer,tResWeb,tResUisvc) 
    # The above statement prints updated values which can then be further processed