Question

因此，如您在下面看到的，我有两个过程，t1和t2，但是我希望t2在满足t1的中断条件时终止，反之亦然。现在我的解决方案不起作用，有人可以告诉我为什么吗？

def distance1():
    while True:
        dist = distance(TRIG1, ECHO1)
        if dist < 0.6 or dist > 6.5:
            print("Nichts")
        elif dist > 0.6 or dist < 6.5:
            print("Entfernung1 = %.1f cm" % dist)
            lcd.lcd_display_string("Achtung! Radfahr-",1)
            lcd.lcd_display_string("rer beachten!",2)
            break

def distance2():
    while break2==False:
        dist2 = distance(TRIG2, ECHO2)
        if dist2 < 0.6 or dist2 > 6.5:
            print("Nichts2")
        elif dist2 > 0.6 or dist2 < 6.5:
            print("Entfernung2 = %.1f cm" % dist2)
            time.sleep(8)
            lcd.lcd_clear()
            break4=True
            break


def distance4():
    while break4==False:
        dist4 = distance(TRIG4, ECHO4)
        if dist4 < 3.0 or dist4 > 12.0:
            print("Nichts4")
        elif dist4 > 3.0 or dist4 < 12.0:
            print("Entfernung4 = %.1f cm" % dist4)
            lcd.lcd_display_string("Stop! Radfahrer ",1)
            lcd.lcd_display_string("  durchlassen!",2)
            for x in range(0, 8):
                GPIO.output(LED, GPIO.HIGH)
                time.sleep(1)
                GPIO.output(LED, GPIO.LOW)
                time.sleep(1)
            lcd.lcd_clear()
            break2=True
            break


t1=Process(target=distance2)
t2=Process(target=distance4)

distance1()
t1.start()
t2.start()

编辑：很抱歉不断更改我的问题，但我想使用全局变量来完成此操作。

Answer 1

（更新：这是对问题进行更改之前的答案，大约是multiprocessing）

当另一个结果给您时，您应该使用t1.terminate()。或者，您可以使用TerminateProcess()

更新2

虽然有一个_stop函数可以停止一个线程，但是不应使用它，因为所有线程都共享资源，并且最终可能会处于中断状态。

更新3

您的变量不是全局变量，要使其在函数开始时全局使用global break4，并在启动线程之前全局定义它们。

Answer 2

您可以引入全局变量或类属性来控制循环的执行：

import threading
import time

class Program():
    run = True

    def distance1(self):
        while self.run:
            print("distance1")
            time.sleep(0.1)

    def distance2(self):
        while self.run:
            print("distance2")
            time.sleep(1)
            self.run = False
    def distance4(self):
        while self.run:
            print("distance4")
            time.sleep(0.1)

p = Program()
t1=threading.Thread(target=p.distance2)
t2=threading.Thread(target=p.distance4)

t1.start()
t2.start()
p.distance1()

在这里，我用distance2杀死了self.run = False的所有3个循环。

此线程中有很多有用的信息：Is there any way to kill a Thread?和有关multiprocessing.Process的答案。

编辑：全局变量几乎相同，只需记住函数中的global run以确保更改了全局run变量，而不是在函数中本地初始化新变量：

import threading
import time

run = True

def distance1():
    global run
    while run:
        print("distance1")
        time.sleep(0.1)

def distance2():
    global run
    while run:
        print("distance2: " + str(run))
        time.sleep(1)
        run = False
def distance4():
    global run
    while run:
        print("distance4")
        time.sleep(0.1)

t1=threading.Thread(target=distance2)
t2=threading.Thread(target=distance4)

t1.start()
t2.start()
distance1()

Answer 3

要记住一些事实：

您不能抢先终止线程。如果要抢先终止，则必须使用进程。或使用协同终止，该终止可同时用于多处理和线程处理，但请阅读第二点以了解一些警告
大多数对象默认情况下不共享，它们将被分叉，以便每个进程都有自己的副本。进程看不到彼此的修改。如果要共享变量，则需要使用共享内存，例如通过使用multiprocessing.Value（）或multiprocessing.Manager（）。对于更复杂的程序，最好将消息传递与multiprocessing.Queue（）一起使用。
全局变量是共享的，这意味着即使threading.Thread和multiprocessing.Process具有相似的接口，但大多数程序在未经进一步修改的情况下相互移植时可能无法正常工作

对于一般情况，您可能需要使用multiprocessing.Value（）/ Array（）在多处理进程之间共享值。

对于设置布尔终止标志的特定用例，可以使用multiprocessing.Event（）或multiprocessing.Condition（）变量来获取。这些是用于在多个线程/进程之间实现许多协作情况的高级构造。

终止Python中的线程

3 个答案: