Python中是否有更好支持超时且不需要轮询的替代线程.Condition变量的方案？

Question

我在使用线程中的条件变量，并且这些线程需要设置超时时间。直到我看到很多线程运行时的CPU使用情况，我才注意到，线程模块中提供的条件变量其实并不会真正让线程休眠，而是在超时的情况下进行轮询。

有没有什么替代方案可以像pthreads那样真正让线程休眠呢？

让很多线程在几秒钟的间隔内休眠，但仍然消耗CPU时间，感觉真是太痛苦了。

谢谢！

Answer 1

我对Python不太熟悉，不过如果你能在一个条件变量上进行阻塞（没有超时），你可以自己实现超时功能。让阻塞的线程记录下它开始阻塞的时间，然后设置一个定时器来提醒它。当它被唤醒时，检查一下经过的时间是否超过了设定的超时。这种做法其实不是很好，除非你能把多个定时器合并到一个线程里，否则你的线程数量会无缘无故地翻倍。

Answer 2

在Python中，这个问题看起来有点棘手，不过这里有一个解决方案。这个方法是通过创建额外的线程来实现的，但它不使用轮询，并且确保原来的线程在超时结束或者原来的wait()返回时能够立即被唤醒。

注意：下面的代码包含一个测试案例，用来测试条件等待是因为超时结束还是因为收到通知。

from thread import start_new_thread
from threading import Condition, Timer

class ConditionWithoutPolling():
    """Implements wait() with a timeout without polling.  Wraps the Condition
    class."""
    def __init__(self, condition):
        self.condition = condition
        self.wait_timeout_condition = Condition()

    def wait(self, timeout=None):
        """Same as Condition.wait() but it does not use a poll-and-sleep method
        to implement timeouts.  Instead, if a timeout is requested two new
        threads are spawned to implement a non-pol-and-wait method."""
        if timeout is None:
            # just use the original implementation if no waiting is involved
            self.condition.wait()
            return
        else:
            # this new boolean will tell us whether we are done waiting or not
            done = [False]

            # wait on the original condition in a new thread
            start_new_thread(self.wait_on_original, (done,))

            # wait for a timeout (without polling) in a new thread
            Timer(timeout, lambda : self.wait_timed_out(done)).start()

            # wait for EITHER of the previous threads to stop waiting
            with self.wait_timeout_condition:
                while not done[0]:
                    self.wait_timeout_condition.wait()

    def wait_on_original(self, done):
        """Waits on the original Condition and signals wait_is_over when done."""
        self.condition.wait()
        self.wait_is_over(done)

    def wait_timed_out(self, done):
        """Called when the timeout time is reached."""
        # we must re-acquire the lock we were waiting on before we can return
        self.condition.acquire()
        self.wait_is_over(done)

    def wait_is_over(self, done):
        """Modifies done to indicate that the wait is over."""
        done[0] = True
        with self.wait_timeout_condition:
            self.wait_timeout_condition.notify()

    # wrap Condition methods since it wouldn't let us subclass it ...
    def acquire(self, *args):
        self.condition.acquire(*args)
    def release(self):
        self.condition.release()
    def notify(self):
        self.condition.notify()
    def notify_all(self):
        self.condition.notify_all()
    def notifyAll(self):
        self.condition.notifyAll()

def test(wait_timeout, wait_sec_before_notification):
    import time
    from threading import Lock
    lock = Lock()
    cwp = ConditionWithoutPolling(Condition(lock))
    start = time.time()

    def t1():
        with lock:
            print 't1 has the lock, will wait up to %f sec' % (wait_timeout,)
            cwp.wait(wait_timeout)
        time_elapsed = time.time() - start
        print 't1: alive after %f sec' % (time_elapsed,)        

    # this thread will acquire the lock and then conditionally wait for up to 
    # timeout seconds and then print a message 
    start_new_thread(t1, ())

    # wait until it is time to send the notification and then send it
    print 'main thread sleeping (will notify in %f sec)' % (wait_sec_before_notification,)
    time.sleep(wait_sec_before_notification)
    with lock:
        cwp.notifyAll()
        print 'notification sent, will continue in 2sec'
    time.sleep(2.0) # give the other time thread to finish before exiting

if __name__ == "__main__":
    print 'test wait() ending before the timeout ...'
    test(2.0, 1.0)

    print '\ntest wait() ending due to the timeout ...'
    test(2.0, 4.0)