Question

我有两个线程，并且，我希望一个线程运行10秒，然后让这个线程停止，同时另一个线程执行，然后第一个线程再次启动;这个过程重复进行。所以例如

from threading import Thread 
import sys  
import time

class Worker(Thread):

    Listened = False; 

    def __init__(self):

        while 1:
           if(self.Listened == False):
              time.sleep(0)
           else:
            time.sleep(20)

        for x in range(0, 10):
            print "I'm working"
            self.Listened = True

    class Processor(Thread):
        Listened = False;

        def __init__(self):
            # this is where I'm confused!!

Worker().start()
Processer().start()

（P.S。我已正确缩进，但是，似乎有点搞砸了）

基本上，我想要的是：

工作线程工作10秒钟（或左右）然后停止，“处理器”启动，一旦处理器处理了“工作”线程的最后一次运行的数据，它就会重新启动“工人”线程起来。我没有必要从当前位置重新启动“工人”线程，它可以从头开始。

有没有人有任何想法？

Answer 1

您可以使用counting semaphore来阻止线程，然后稍后将其唤醒。

计数信号量是具有非负整数计数的对象。如果一个线程在计数为0时调用信号量上的acquire()，则该块将阻塞，直到信号量的计数大于零。要解除阻塞线程，另一个线程必须通过调用信号量上的release()来增加信号量的计数。

创建两个信号量，一个用于阻止工作，一个用于阻止处理器。因为我们希望它立即运行，所以启动工人信号量的计数为1。将处理器的信号量计数设置为0，因为我们希望它在工作完成之前阻塞。

将信号量传递给worker和processor类。在工作者运行10秒后，它应该通过调用processorSemaphore.release()来唤醒处理器，然后它应该通过调用workerSemaphore.acquire()在其信号量上休眠。处理器也是如此。

#!/usr/bin/env python
from threading import Thread, Semaphore
import sys  
import time

INTERVAL = 10

class Worker(Thread):

    def __init__(self, workerSemaphore, processorSemaphore):
        super(Worker, self).__init__()
        self.workerSemaphore    = workerSemaphore
        self.processorSemaphore = processorSemaphore

    def run(self):
        while True:
            # wait for the processor to finish
            self.workerSemaphore.acquire()
            start = time.time()
            while True:
                if time.time() - start > INTERVAL:
                    # wake-up the processor
                    self.processorSemaphore.release()
                    break

                # do work here
                print "I'm working"

class Processor(Thread):
    def __init__(self, workerSemaphore, processorSemaphore):
        super(Processor, self).__init__()
        print "init P"
        self.workerSemaphore    = workerSemaphore
        self.processorSemaphore = processorSemaphore

    def run(self):
        print "running P"
        while True:
            # wait for the worker to finish
            self.processorSemaphore.acquire()
            start = time.time()
            while True:
                if time.time() - start > INTERVAL:
                    # wake-up the worker
                    self.workerSemaphore.release()
                    break

                # do processing here
                print "I'm processing"

workerSemaphore    = Semaphore(1)
processorSemaphore = Semaphore(0)

worker    = Worker(workerSemaphore, processorSemaphore)
processor = Processor(workerSemaphore, processorSemaphore)

worker.start()
processor.start()

worker.join()
processor.join()

Answer 2

见阿尔瓦罗的回答。但如果你必须真正使用线程，那么你可以做类似下面的事情。但是，您只能在start()对象上调用Thread一次。因此，您的数据应该保留关于下一个Worker线程应该从哪里开始的状态，并且每次在Processor中创建一个新的工作线程，或者尝试使用临界区以便{{1} }和Worker线程可以轮流访问它。

Processor

Python - 是否可以“停止”或“暂停”一个线程

2 个答案: