每隔n秒做一次沒有while循環的事情？

Question

嗯，我正在嘗試爲Blender編寫一個附加組件，並且我需要每n秒執行一次，但是，我無法使用while循環，因爲它凍結了Blender！我該怎麼辦？

Answer 1

從Blender API文檔的Strange errors using ‘threading’ module：

Python和Blender的線程，只有當線程完成了腳本執行之前正常工作。例如，使用threading.join（）。

注意：Pythons線程只允許使用同幣種，並且不會加速多處理器系統上的腳本，子進程和多進程模塊可以與攪拌器一起使用，也可以使用多個CPU。

from threading import Thread, Event 

class Repeat(Thread): 
    def __init__(self,delay,function,*args,**kwargs): 
     Thread.__init__(self) 
     self.abort = Event() 
     self.delay = delay 
     self.args = args 
     self.kwargs = kwargs 
     self.function = function 
    def stop(self): 
     self.abort.set() 
    def run(self): 
     while not self.abort.isSet(): 
      self.function(*self.args,**self.kwargs) 
      self.abort.wait(self.delay) 

例子：

from time import sleep 
def do_work(foo): 
    print "busy", foo 
r = Repeat(1,do_work,3.14) # execute do_work(3.14) every second 
r.start() # start the thread 
sleep(5) # let this demo run for 5s 
r.stop() # tell the thread to wake up and stop 
r.join() # don't forget to .join() before your script ends 

Answer 2

import threading 

def hello(): 
    print "hello, world" 
    t = threading.Timer(30.0, hello) 
    t.start() # after 30 seconds, "hello, world" will be printed 

我不是很好用蟒蛇，並沒有試過這個。看看這可以幫助您:)

Answer 3

from threading import Timer 

def doSomeThings(): 
    print "Things are being done" 

t = Timer(5.0, doSomeThings) # every 5 seconds 
t.start() 

Answer 4

根據您的需求，time.sleep或threading.Timer可能做的工作。

如果你需要一個更全面的調度，我最喜歡的版本是在http://code.activestate.com/recipes/496800-event-scheduling-threadingtimer/發現配方：

import thread 
import threading 

class Operation(threading._Timer): 
    def __init__(self, *args, **kwargs): 
     threading._Timer.__init__(self, *args, **kwargs) 
     self.setDaemon(True) 

    def run(self): 
     while True: 
      self.finished.clear() 
      self.finished.wait(self.interval) 
      if not self.finished.isSet(): 
       self.function(*self.args, **self.kwargs) 
      else: 
       return 
      self.finished.set() 

class Manager(object): 

    ops = [] 

    def add_operation(self, operation, interval, args=[], kwargs={}): 
     op = Operation(interval, operation, args, kwargs) 
     self.ops.append(op) 
     thread.start_new_thread(op.run,()) 

    def stop(self): 
     for op in self.ops: 
      op.cancel() 

class LockPrint(object): 
    def __init__(self): 
     self.lock = threading.Lock() 
    def lprint(self, value): 
     with self.lock: 
      print value 

if __name__ == '__main__': 
    import time 
    import datetime 

    lp = LockPrint() 

    def hello1(): 
     lp.lprint('{}\thello1!'.format(datetime.datetime.now())) 
    def hello2(): 
     lp.lprint('{}\thello2!'.format(datetime.datetime.now())) 
    def hello3_blocking(): # this is bad, so don't do it in real code ;) 
     lp.lprint('{}\thello3_blocking starting... '.format(
      datetime.datetime.now() 
     )), 
     t = time.time() # get a timestamp 
     x = 0 
     while time.time() - t < 3: # iterate in a blocking loop for 3 secs 
      x += 1 
     lp.lprint('{}\thello3_blocking complete! ({} iterations)'.format(
      datetime.datetime.now(), x 
     )) 



    timer = Manager() 
    timer.add_operation(hello1, 1) 
    timer.add_operation(hello2, 2) 
    timer.add_operation(hello3_blocking, 2) 

    t0 = time.time() 
    while time.time() - t0 < 10: 
     time.sleep(0.1) 
    # turn off everything and exit... 
    timer.stop() 

這通常是一次安全的，在這個意義上，因爲每次操作一個線程在執行時，主線程仍然可以切換單個操作線程中的阻塞部分，並在其他操作上維護時間表（假設您的函數不會在解釋器一直引發任何異常，打破主調度器線程...）

我不知道這將如何與攪拌機，但它的工作在我使用過的其他環境（特別是基於龍捲風的服務器）時，它處於非阻塞模式。