python - 如何正确使用倒计时线程，如何提前停止它？

Question

线程未按我预期的方式工作。

我有一个可行的解决方案，可以使用 Raspberry Pi 和簧片开关监控冰箱何时打开和关闭(声音播放未暂停和暂停)。我现在想添加一个计时器，以便在门打开时间过长时执行某些操作。我认为启动一个在警报操作之前休眠 x 秒的线程是一个好主意。当开关再次关闭时，我会用信号杀死线程。

我的方法失败了。 CountDown 运行线程已启动，但终止信号命令已执行但没有效果。此外，c.terminate() 之后的命令不会执行。我查看了线程的示例，但它们似乎适用于更复杂的情况。我错过了什么？

代码:

#!/usr/bin/env python2.7

import threading, subprocess, sys, time, syslog
import RPi.GPIO as GPIO

sound = "/home/pi/sounds/fridge_link.mp3" # sound to play while switch is open
cmd = ['mplayer', '-nolirc', '-noconsolecontrols', '-slave', '-quiet', sound] # command to play sound
lim = 10 # seconds until warning

# thread for countdown (should be interruptable)
# based on http://chimera.labs.oreilly.com/books/1230000000393/ch12.html#_solution_197
class CountdownTask:
    def __init__(self):
        self._running = True

    def terminate(self):
        self._running = False
        print("thread killed")

    def run(self, n):
        print("start timer")
        time.sleep(n)
        ## action when timer isup 
        print("timer ended")


c = CountdownTask()
t = threading.Thread(target=c.run, args=(lim,))
t.daemon = True

p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
p.stdin.write('\npausing_keep pause\n')

REED = 27 # data pin of reed sensor (in)

# GPIO setup
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(REED,GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

def edge(channel):
    if GPIO.input(REED):
        print("detect close")
        c.terminate()
        p.stdin.write('\npause\n')
        pass
    else:
        print("detect open")
        t.start()
    p.stdin.write('\npausing_toggle pause\n')

def main():
    GPIO.add_event_detect(REED, GPIO.BOTH,callback=edge,bouncetime=1000)
    while True:
        time.sleep(0.2)
        pass

#------------------------------------------------------------

if __name__ == "__main__": main()

新版本:

#!/usr/bin/env python2.7

import threading, subprocess, sys, time, syslog
import RPi.GPIO as GPIO

sound = "/home/pi/sounds/fridge_link.mp3" # sound to play while switch is open
cmd = ['mplayer', '-nolirc', '-noconsolecontrols', '-slave', '-quiet', sound] # command to play sound
lim = 10 # seconds until warning

# thread for countdown (should be interruptable)
class CountdownTask:
    global dooropen
    def __init__(self):
        self._running = True

    def terminate(self):
        self._running = False
        print("thread killed")

    def run(self, n):
      while self._running and dooropen == False:
          time.sleep(0.2)
          pass
      while self._running and dooropen:
        print("start timer")
        time.sleep(n)
        ## action when timer isup 
        print("timer ended")


c = CountdownTask()
t = threading.Thread(target=c.run, args=(lim,))
t.daemon = True

p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
p.stdin.write('\npausing_keep pause\n')

REED = 27 # data pin of reed sensor (in)

# GPIO setup
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(REED,GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

dooropen = False # assuming door's closed when starting


def edge(channel):
    global dooropen
    if GPIO.input(REED): # * no longer reached
        if dooropen == False: # catch fridge compressor spike
            print("false close alert") 
            return
        p.stdin.write('\npause\n') 
        dooropen = False
        pass
    else:
        print("detect open")
        if dooropen == True:
            print("false open alert")
            return        
    p.stdin.write('\npausing_toggle pause\n')
    dooropen = True

def main():
    GPIO.add_event_detect(REED, GPIO.BOTH,callback=edge,bouncetime=1000)
    t.start()
    while True:
        time.sleep(0.2)
        pass

#------------------------------------------------------------

if __name__ == "__main__": main()

调整后的部分，现在工作:

    def run(self, n):
      while self._running and dooropen == False:
          time.sleep(0.2)
          pass
      while self._running and dooropen:
        time.sleep(n)
        if dooropen:
            ## action when timer isup 

Answer 1

您通过 self._running 编写的线程终止机制不起作用，因为您没有在 run( ) 胎面的方法(实际上是在您提到的示例中完成的)。

定期轮询会增加复杂性，但这里没有必要。您应该以不同的方式构建逻辑，这种方式简单且可靠。示例代码:

import threading
import time


dooropen = True


def warnafter(timeout):
    time.sleep(timeout)
    if dooropen:
        print("Warning!")


t = threading.Thread(target=warnafter, args=(2,))
t.start()
time.sleep(1)
dooropen = False
t.join()

将 time.sleep(1) 更改为 time.sleep(3) 并打印警告。为什么它有效？它如何转化为您的用例？

首先，让我们给事物命名。您有主线程和“警告线程”。这些是我的示例代码中的架构的基石:

• 两个线程之间有一个共享状态，指示门是否打开，转化为是否应该发出警告的事实。我们将此状态称为 dooropen，它可以是 True 或 False。它是一个可以在主线程的范围以及警告线程可以访问的范围内访问的变量。也就是说，它存在于共享内存中。

• 这是您的约定:dooropen 仅从主线程写入。警告线程只读取它。

• 只要您认为合适的时间，就生成您的警告线程。使其 sleep (确切的 sleep 时间可能不可靠，尤其是在嵌入式系统上)。

• 关键部分:在警告线程中发出警报之前，使其检查dooropen状态。如果没有开门，就不要发出警报!

你看到这两种不同的范式了吗？

你的范例是放置一个武装炸弹，编程为在给定的时间后爆炸。这颗炸弹不再跟你顶嘴了。你的希望是，如果你不再需要它爆炸的话，你能够在炸弹爆炸之前拆除/摧毁它。

我提出的范例运送了一颗炸弹，实际上直到需要时才武装起来。当你的炸弹简单地爆炸时，这颗炸弹会询问它是否真的应该这样做，然后才会武装自己并爆炸。

考虑到后一种范例，如果警告线程被告知不要执行其操作，它会自行静默退出。不需要“从外部终止线程”的概念!

实际上，您需要一些更高级的概念，其中警告线程有自己的事件开关。也就是说，您的主线程可以以受控方式停用单个警告线程。请参阅此示例:

import threading
import time


class WarnThread(threading.Thread):
    def __init__(self, timeout, name):
        threading.Thread.__init__(self)
        self._timeout = timeout
        self.active = True
        self.name = name
        self.start()

    def run(self):
        self._warnafter()

    def _warnafter(self):
        time.sleep(self._timeout)
        if self.active:
            print("WarnThread %s: Warning after timeout" % self.name)


ws = [WarnThread(2, i) for i in range(5)]

# Simulate spending some time doing other things,
# such as responding to external events.
time.sleep(1)

# Selectively deactivate some of the warn threads.
ws[0].active = False
ws[2].active = False

for w in ws:
    w.join()

输出:

WarnThread 4: Warning after timeout
WarnThread 1: Warning after timeout
WarnThread 3: Warning after timeout