我正在使用一个线程从流(/ dev/tty1)读取字符串,同时处理主循环中的其他内容.我想在按CTRL-C时Thread与主程序一起终止.
from threading import Thread
class myReader(Thread):
def run(self):
with open('/dev/tty1', encoding='ascii') as myStream:
for myString in myStream:
print(myString)
def quit(self):
pass # stop reading, close stream, terminate the thread
myReader = Reader()
myReader.start()
while(True):
try:
pass # do lots of stuff
KeyboardInterrupt:
myReader.quit()
raise
通常的解决方案 - run()循环中的布尔变量 - 在这里不起作用.推荐的解决方法是什么？
我可以设置守护进程标志,但之后我将无法使用quit()方法,这可能在以后证明是有价值的(做一些清理).有任何想法吗？
可能的重复：
有没有办法杀死Python中的线程？
我们知道 pthread 库支持 pthread_kill() 来杀死对等线程，但我只是想知道为什么 python 不支持此功能？任何答案都有帮助，谢谢，:)
我想要一种方法来生成一个等待用户输入的线程; 如果在10秒内没有输入任何输入,我希望脚本终止生成的线程并继续处理.如果输入文本,我有办法从线程中获取输入但是我无法让超时终止新生成的线程.
在下面的例子中,我是最接近的.我告诉新创建的线程它是一个守护进程,它将在主脚本退出时退出.我对此的问题是该线程将继续等待,直到脚本退出或用户输入了某些内容.
shared_var = ['1']
def run(ref):
ref[0] = raw_input("enter something: ")
print "shared var changed to '%s'" % (ref[0])
thread = threading.Thread(target=run, args=(shared_var,))
thread.daemon = True
thread.start()
time.sleep(10) # simplified timeout
#Need some way to stop thread if no input has been entered
print "shared var = " + shared_var[0]
我知道突然杀死一个线程不是最好的方法(相关链接),但我不知道如何中断等待raw_input的新线程
我想编写一个函数，该函数将在5秒后返回：
def myfunction():
while passed_time < 5_seconds:
do1()
do2()
do3()
.
.
return
我的意思是，此功能仅运行5秒钟，在5秒钟后，它应结束并继续使用其他功能：
myfunction()
otherfunction() ----> This should start 5 seconds after myfunction() is executed.
最好的祝福
我有一个 python 程序，它实现了这样的线程：
class Mythread(threading.Thread):
def __init__(self, name, q):
threading.Thread.__init__(self)
self.name = name
self.q = q
def run(self):
print "Starting %s..." % (self.name)
while True:
## Get data from queue
data = self.q.get()
## do_some_processing with data ###
process_data(data)
## Mark Queue item as done
self.q.task_done()
print "Exiting %s..." % (self.name)
def call_threaded_program():
##Setup the threads. Define threads,queue,locks
threads = []
q = Queue.Queue()
thread_count = n #some number
data_list = [] #some data list containing data
##Create Threads
for …我有一个应用程序,每隔几分钟轮询一堆服务器.为此,它为每个服务器生成一个线程进行轮询(15个服务器)并将数据写回到对象:
import requests
class ServerResults(object):
def __init__(self):
self.results = []
def add_server(some_argument):
self.results.append(some_argument)
servers = ['1.1.1.1', '1.1.1.2']
results = ServerResults()
for s in servers:
t = CallThreads(poll_server, s, results)
t.daemon = True
t.start()
def poll_server(server, results):
response = requests.get(server, timeout=10)
results.add_server(response.status_code);
该CallThreads班是一个辅助函数来调用一个函数(在这种情况下,poll_server()带有参数(在这种情况下s和results),你可以在我的GitHub库看到源Python的实用功能.大部分能正常工作的时间,但是有时候一个线程间歇我不知道为什么,因为我在GET请求上使用了超时.无论如何,如果线程挂起,则挂起的线程会在数小时或数天内累积,然后Python崩溃:
File "/usr/lib/python2.7/threading.py", line 495, in start
_start_new_thread(self.__bootstrap, ())
thread.error: can't start new thread
Exception in thread Thread-575 (most likely raised during interpreter shutdown)
Exception in thread …在 Windows 上使用 python 3.4。
我正在尝试终止模拟一个人按 Ctrl+C（在 linux 上为 Ctrl+D）的子进程。
我只是添加了处理程序来检查信号是否正在被处理。我使用了这个问题的想法
目标是捕获 KeyboardInterrupt (SIGINT)，并释放资源。但如果 SIGINT 不是来自键盘，似乎不会抛出异常。这就是为什么我创建了一个处理程序，但该进程似乎根本没有运行该处理程序......
import multiprocessing
import time
import signal
import signal
import os
import sys
def handler(signal, frame):
print("handler!!!")
sys.exit(10)
def worker():
p = multiprocessing.current_process()
try:
signal.signal(signal.SIGINT,handler)
print("[PID:{}] acquiring resources".format(p.pid))
while(True):
#working...
time.sleep(0.5)
except (KeyboardInterrupt, SystemExit):
pass
finally:
print("[PID:{}] releasing resources".format(p.pid))
if __name__ == "__main__":
lst = []
for i in range(1):
p = multiprocessing.Process(target=worker)
p.start()
lst.append(p)
time.sleep(3)
for p in lst:
os.kill(p.pid,signal.SIGINT)
p.join()
print(p)
print(p.exitcode) …我有几个类看起来或多或少是这样的：
import threading
import time
class Foo():
def __init__(self, interval, callbacks):
self.thread = threading.Thread(target=self.loop)
self.interval = interval
self.thread_stop = threading.Event()
self.callbacks = callbacks
def loop():
while not self.thread_stop.is_set():
#do some stuff...
for callback in self.callbacks():
callback()
time.sleep(self.interval)
def start(self):
self.thread.start()
def kill(self):
self.thread_stop.set()
我在我的主线程中使用的是这样的：
interval = someinterval
callbacks = [some callbacks]
f = Foo(interval, callbacks)
try:
f.start()
except KeyboardInterrupt:
f.kill()
raise
在所有回调完成后，但在循环重复之前，我想要一个 KeyboardInterrupt 来终止线程。目前它们被忽略，我不得不求助于终止程序运行的终端进程。
我从这篇文章中看到了使用 threading.Event 的想法，但看起来我做错了，这让这个项目的工作变得非常麻烦。
我不知道它是否相关，但是我从 Internet 传递访问数据的回调并大量使用重试装饰器来处理不可靠的连接。
编辑
在大家的帮助下，循环现在在 Foo 中看起来像这样：
def thread_loop(self):
while not …我正在尝试创建一个看门狗类，它将在指定时间后抛出异常：
from threading import Timer
from time import sleep
class watchdog():
def _timeout(self):
#raise self
raise TypeError
def __init__(self):
self.t = Timer(1, self._timeout)
def start(self):
self.t.start()
try:
w = watchdog()
w.start()
sleep(2)
except TypeError, e:
print "Exception caught"
else:
print "Of course I didn't catch the exception"
该异常未被捕获，因为该异常是从完全不同的上下文引发的，因此我们将看到最后一条消息。
我的问题是，如何修改代码，以便捕获异常？
我有这个代码,如何从func1停止func2？类似的东西Thread(target = func1).stop()不起作用
import threading
from threading import Thread
def func1():
while True:
print 'working 1'
def func2():
while True:
print 'Working2'
if __name__ == '__main__':
Thread(target = func1).start()
Thread(target = func2).start()