如何让线程将元组或我选择的任何值返回给 Python 中的父级？
问问题
95723 次
13 回答
68
我建议您在启动线程之前实例化一个Queue.Queue，并将其作为线程的参数之一传递：在线程完成之前，它.put是作为参数接收的队列中的结果。父母可以.get或随意.get_nowait。
队列通常是在 Python 中安排线程同步和通信的最佳方式：它们本质上是线程安全的消息传递工具——通常是组织多任务处理的最佳方式！-)
于 2009-12-11T06:24:14.917 回答
15
您应该将 Queue 实例作为参数传递，然后您应该将返回对象 .put() 放入队列中。您可以通过 queue.get() 收集您放置的任何对象的返回值。
样本：
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)
用于多个线程：
#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()
我使用这个实现，它对我很有用。我希望你这样做。
于 2013-04-22T10:11:33.763 回答
12
如果您调用 join() 来等待线程完成，您可以简单地将结果附加到 Thread 实例本身，然后在 join() 返回后从主线程中检索它。
另一方面，您没有告诉我们您打算如何发现线程已完成并且结果可用。如果您已经有办法做到这一点，它可能会为您（以及我们，如果您告诉我们）指出获得结果的最佳方式。
于 2009-12-12T01:27:10.220 回答
12
使用lambda包装目标线程函数，并使用queue将其返回值传递回父线程。（您的原始目标函数保持不变，没有额外的队列参数。）
示例代码：
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())
输出：
4
于 2014-02-23T00:34:44.673 回答
8
我很惊讶没有人提到你可以把它传递给一个可变的：
>>> thread_return={'success': False}
>>> from threading import Thread
>>> def task(thread_return):
... thread_return['success'] = True
...
>>> Thread(target=task, args=(thread_return,)).start()
>>> thread_return
{'success': True}
也许这有我不知道的主要问题。
于 2015-12-07T11:51:49.403 回答
5
另一种方法是将回调函数传递给线程。这提供了一种简单、安全和灵活的方式，可以随时从新线程向父级返回值。
# 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()
于 2009-12-11T07:35:54.633 回答
3
您可以使用同步队列模块。
考虑您需要从具有已知 ID 的数据库中检查用户信息：
def check_infos(user_id, queue):
result = send_data(user_id)
queue.put(result)
现在您可以像这样获取数据：
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()
于 2015-08-15T08:10:36.823 回答
2
POC：
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
于 2015-01-26T21:08:29.663 回答
2
对于简单的程序，上面的答案对我来说有点矫枉过正。我会使用可变方法：
class RetVal:
def __init__(self):
self.result = None
def threadfunc(retVal):
retVal.result = "your return value"
retVal = RetVal()
thread = Thread(target = threadfunc, args = (retVal))
thread.start()
thread.join()
print(retVal.result)
于 2018-11-30T09:50:00.183 回答
1
好吧，在 Python 线程模块中，有一些条件对象与锁相关联。一种方法acquire()将返回从底层方法返回的任何值。更多信息：Python 条件对象
于 2009-12-11T06:10:05.033 回答
1
基于 jcomeau_ictx 的建议。我遇到的最简单的一个。这里的要求是从服务器上运行的三个不同进程获取退出状态，如果这三个进程都成功，则触发另一个脚本。这似乎工作正常
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
于 2016-06-17T03:36:11.397 回答
0
以下包装函数将包装现有函数并返回一个对象，该对象既指向线程（以便您可以在其上调用start()、join()等）以及访问/查看其最终返回值。
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
它看起来不错，并且threading.Thread该类似乎很容易使用这种功能扩展（*），所以我想知道为什么它还不存在。上述方法有缺陷吗？
(*) 请注意，husanu 对这个问题的回答正是这样做的，子类化threading.Thread产生了一个版本，其中join()给出了返回值。
于 2016-03-22T14:04:04.890 回答
0
这是实现多线程的代码。
线程 1 是从 10 到 20 的数字相加。线程 2 是从 21 到 30 的数字相加。
最后输出返回到主程序，在那里它可以执行最终的加法。（此程序中未显示）但您可以使用 numpy 调用。
import threading
import os
import queue
def task1(num, queue):
print("\n Current thread: {}".format(threading.current_thread().name))
count = 0
sum1 = 0
while count <= 10:
sum1 = sum1 + num
num = num + 1
count = count + 1
print('\n'+str(sum1))
queue.put(sum1)
if __name__ == "__main__":
queue = queue.Queue()
# print ID of current process
print("\n Process ID is: {}".format(os.getpid()))
# print name of main thread
print("\n Main thread is: {}".format(threading.main_thread().name))
# creating threads
t1 = threading.Thread(target=task1, name='t1',args=[10,queue])
t2 = threading.Thread(target=task1, name='t2',args=[21,queue])
#Store thread names in a list
pool = [t1,t2]
#Used to store temporary values
thread_results = []
# starting threads
#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()
print(thread_results)
于 2020-02-21T17:11:58.903 回答