Python—是否可以；停止“；或；暂停“；线

我有两个线程，我希望一个线程运行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()

（顺便说一句，我已经正确缩进了，所以看起来有点搞砸了）

基本上，我想要的是：

工作线程工作10秒左右，然后停止，“处理器”启动，一旦处理器处理了“工作线程”最后一次运行的数据，它就会重新启动“工作线程”。我不需要从当前位置重新启动“worker”线程，它可以从头开始

---

有人有什么想法吗

见阿尔瓦罗的答案。但是，如果您真的必须使用线程，那么您可以执行以下操作。但是，只能对

线程
对象调用一次
start（）
。因此，要么您的数据应该保留下一个
工作者
线程应该从何处开始的状态，并且您每次都在
处理器
中创建一个新的工作者线程，要么尝试使用一个关键部分，以便
工作者
和
处理器
线程可以轮流访问它

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

class Worker(Thread):

    def __init__(self):
        Thread.__init__(self)
        pass

    def run(self):
        for x in range(0, 10):
            print "I'm working"
            time.sleep(1)

class Processor(Thread):

    def __init__(self, w):
        Thread.__init__(self)
        self.worker = w

    def run(self):
            # process data from worker thread, add your logic here
            self.worker.start()

w = Worker()    
p = Processor(w)
p.start()

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

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

创建两个信号量，一个用于阻止工作进程，另一个用于阻止处理器。启动工作信号量的计数a 1，因为我们希望它立即运行。启动处理器的信号量计数为0，因为我们希望它阻塞，直到工作进程完成

将信号量传递给worker和processor类。工作进程运行10秒后，应通过调用
processorsemapore.release（）
唤醒处理器，然后通过调用
workersemapore.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()

它们是否同时运行过？@Alvaro否，因为我正在录制声音，因此，在处理之前检测到的声音之前，不应再录制声音。。因此，我应该只使用函数吗？是的，如果它们不能同时运行，则不需要使用多线程。。。您甚至可以使用回调，但最好的方法是按顺序运行它们。。。第一个完成后，开始第二个好的。。非常感谢。我来试试：）不要用分号