Python中来自线程的定期回调

我的程序从我的

spam

方法在新线程中调用方法

baz

现在我需要在这个新线程中每秒检查self.track的值

import threading
class A(threading.Thread):

def __init__(self, player):
    self.track = True

def Baz(self):
    // how do i check the value of self.track every 1 second here
    while self.track:
        // do something


def Spam(self):
    player_thread = Thread(target=self.Baz)
    player_thread.start()

---

我怎么检查它，说每一秒

你检查，然后在循环中睡眠一秒钟。

你检查，然后在循环中睡眠一秒钟。

使用

时间。睡眠

：

from time import sleep

def Baz(self):
    // Will check self.track each second until it becomes true
    while not self.track:
        sleep(1)

    while self.track:
        //do something

---

根据您试图实现的目标，您可能需要阅读一些关于api的内容。这通常比使用定期探测要好。

使用

时间。睡眠
：

from time import sleep

def Baz(self):
    // Will check self.track each second until it becomes true
    while not self.track:
        sleep(1)

    while self.track:
        //do something

根据您试图实现的目标，您可能需要阅读一些关于api的内容。这通常比使用定期探测要好。
如果您想轮询，只需在循环内使用
时间。睡眠

import time
...
    while self.track:
        time.sleep(1)

如果您希望获得更高的精度，例如，如果您正在循环中执行其他操作，并且这些操作占用了大量的时间，那么您可以执行以下操作：

...
while self.track:
    start = time.time()
    # Do things here
    sleep_time = start-time.time() + 1
    if sleep_time > 0:
        time.sleep(sleep_time)

如果您希望阻止线程，则也可以从另一个角度来进行此操作，直到
self.track
设置为
True
，并且所有辅助线程都将在此之前创建

class A(object):

    def __init__(self, player):
        self._track = False
        self.player = player
        self._track_condition = threading.Condition()
    @property
    def track(self):
        return self._track
    @track.setter(self, value):
        if value:
            self._track_condition.acquire()
            self._track_condition.notify_all()
            self._track_condition.release()
        self._track = value
   def baz(self):
       self._track_condition.acquire()
       self._track_condition.wait()
       self._track_condition.release()
       while self.track:
           # Do stuff
   def spam(self):
       player_thread = threading.Thread(target=self.baz)
       player_thread.start()

不过我要指出的是，除非您的播放器操作是受I/O限制的，
线程化可能不会对性能产生多大影响，甚至可能会损害性能<代码>线程。线程
s都位于中，因此它们实际上无法并行执行。如果你想这样做，你需要。
如果你想投票，只需在循环中使用
time.sleep

import time
...
    while self.track:
        time.sleep(1)

如果您希望获得更高的精度，例如，如果您正在循环中执行其他操作，并且这些操作占用了大量的时间，那么您可以执行以下操作：

...
while self.track:
    start = time.time()
    # Do things here
    sleep_time = start-time.time() + 1
    if sleep_time > 0:
        time.sleep(sleep_time)

如果您希望阻止线程，则也可以从另一个角度来进行此操作，直到
self.track
设置为
True
，并且所有辅助线程都将在此之前创建

class A(object):

    def __init__(self, player):
        self._track = False
        self.player = player
        self._track_condition = threading.Condition()
    @property
    def track(self):
        return self._track
    @track.setter(self, value):
        if value:
            self._track_condition.acquire()
            self._track_condition.notify_all()
            self._track_condition.release()
        self._track = value
   def baz(self):
       self._track_condition.acquire()
       self._track_condition.wait()
       self._track_condition.release()
       while self.track:
           # Do stuff
   def spam(self):
       player_thread = threading.Thread(target=self.baz)
       player_thread.start()

不过我要指出的是，除非您的播放器操作是受I/O限制的，
线程化可能不会对性能产生多大影响，甚至可能会损害性能<代码>线程。线程
s都位于中，因此它们实际上无法并行执行。如果你想要的话，你需要。
我承认我对此不是100%肯定，但我认为至少在某些平台上，
time.sleep（）
实际上是在操作系统级别
select
下实现的。我承认我对此不是100%肯定，但我认为至少在某些平台上，
time.sleep（）
实际上是通过操作系统级别
select
在引擎盖下实现的。