5

2 つのスレッドがあり、1 つのスレッドを 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()

（PS私は正しくインデントしましたが、SOはそれを少し台無しにしたようです）

基本的に、私が欲しいのは：

ワーカー スレッドは 10 秒 (またはそれくらい) 動作してから停止し、「プロセッサ」が起動し、プロセッサが「ワーカー」スレッドの最後の実行からのデータを処理すると、「ワーカー」を再起動します。スレッドアップ。その現在の位置から「ワーカー」スレッドを特に再起動する必要はありません。最初から開始できます。

誰にもアイデアはありますか？

4

2 に答える 2

1

カウント セマフォを使用してスレッドをブロックし、後でウェイクアップすることができます。

カウンティング セマフォは、負でない整数カウントを持つオブジェクトです。カウントが 0 のときにスレッドがセマフォを呼び出すと、スレッドはacquire()セマフォのカウントが 0 より大きくなるまでブロックされます。スレッドのブロックを解除するには、別のスレッドがセマフォを呼び出してセマフォのカウントを増やす必要がありますrelease()。

2 つのセマフォを作成します。1 つはワーカーをブロックし、もう 1 つはプロセッサをブロックします。ワーカー セマフォをすぐに実行したいので、ワーカー セマフォのカウントを 1 から開始します。ワーカーが完了するまでブロックする必要があるため、プロセッサのセマフォのカウントを 0 から開始します。

セマフォをワーカー クラスとプロセッサ クラスに渡します。ワーカーが 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()
于 2013-09-29T00:19:08.137 に答える
0

アルバロの答えを見てください。しかし、本当にスレッドを使用する必要がある場合は、以下のようにすることができます。start()ただし、Threadオブジェクトを呼び出すことができるのは 1 回だけです。したがって、データは次のスレッドの開始位置に関する状態を保持する必要があり、毎回Worker新しいワーカー スレッドを作成するか、クリティカル セクションを使用してとスレッドが順番にアクセスできるようにする必要があります。ProcessorWorkerProcessor

#!/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()
于 2013-09-28T23:41:35.893 に答える