Wie zum starten und beenden thread?

Sorry für die alte Frage. Ich habe geklärt. Wie kann ich ein stop thread mit meinen Armen thread-Klasse?

BEARBEITEN: Es ist in der Schleife, I want to restart es wieder an den Anfang des Codes. Wie kann ich start-beenden-neu starten-beenden-neu starten?

Meiner Klasse:

import threading

class Concur(threading.Thread):
    def __init__(self):
        self.stopped = False
        threading.Thread.__init__(self)

    def run(self):
        i = 0
        while not self.stopped:
            time.sleep(1)
            i = i + 1

In der Haupt-code, die ich will:

inst = Concur()

while conditon:
    inst.start()

    #after some operation
    inst.stop()
    #some other operation

InformationsquelleAutor user2229183 | 2013-03-31

multithreading python

Dies ist David Heffernan Idee prall-out. Das Beispiel unten läuft für 1 Sekunde, dann Stoppt für 1 Sekunde, dann läuft für 1 Sekunde, und so weiter.

import time
import threading
import datetime as DT
import logging
logger = logging.getLogger(__name__)

def worker(cond):
    i = 0
    while True:
        with cond:
            cond.wait()
            logger.info(i)
            time.sleep(0.01)
            i += 1

logging.basicConfig(level=logging.DEBUG,
                    format='[%(asctime)s %(threadName)s] %(message)s',
                    datefmt='%H:%M:%S')

cond = threading.Condition()
t = threading.Thread(target=worker, args=(cond, ))
t.daemon = True
t.start()

start = DT.datetime.now()
while True:
    now = DT.datetime.now()
    if (now-start).total_seconds() > 60: break
    if now.second % 2:
        with cond:
            cond.notify()

InformationsquelleAutor unutbu

Kann man eigentlich nicht stoppen und dann neu starten einen thread, da kann man nicht anrufen, seine start() wieder nach seiner run() - Methode wurde beendet. Allerdings können Sie eine einzustellen und eine spätere Wiederaufnahme der Ausführung durch die Verwendung eines threading.Bedingung variable zu vermeiden, concurrency-Probleme beim prüfen oder ändern Ihren Zustand ausgeführt werden.

threading.Condition Objekte zugeordnet sind, threading.Lock Objekt und Methoden, um zu warten, bis es veröffentlicht und benachrichtigt alle wartenden threads, wenn das Auftritt. Hier ist ein Beispiel, abgeleitet aus dem code in deiner Frage, die zeigt diesen Vorgang. In dem Beispiel code, ich habe die Condition variable Teil Thread Unterklasse-Instanzen, um eine bessere Kapselung der Implementierung und vermeiden benötigen, um die Einführung eines zusätzlichen globalen Variablen:

from __future__ import print_function
import threading
import time

class Concur(threading.Thread):
    def __init__(self):
        super(Concur, self).__init__()
        self.iterations = 0
        self.daemon = True  # Allow main to exit even if still running.
        self.paused = True  # Start out paused.
        self.state = threading.Condition()

    def run(self):
        self.resume()
        while True:
            with self.state:
                if self.paused:
                    self.state.wait()  # Block execution until notified.
            # Do stuff.
            time.sleep(.1)
            self.iterations += 1

    def resume(self):
        with self.state:
            self.paused = False
            self.state.notify()  # Unblock self if waiting.

    def pause(self):
        with self.state:
            self.paused = True  # Block self.


class Stopwatch(object):
    """ Simple class to measure elapsed times. """
    def start(self):
        """ Establish reference point for elapsed time measurements. """
        self.start_time = time.time()
        return self.start_time

    @property
    def elapsed_time(self):
        """ Seconds since started. """
        try:
            start_time = self.start_time
        except AttributeError:  # Wasn't explicitly started.
            start_time = self.start()

        return time.time() - start_time


MAX_RUN_TIME = 5  # Seconds.
concur = Concur()
stopwatch = Stopwatch()

print('Running for {} seconds...'.format(MAX_RUN_TIME))
concur.start()
while stopwatch.elapsed_time < MAX_RUN_TIME:
    concur.resume()
    # ... do some concurrent operations.
    concur.pause()
    # Do some other stuff...

# Show Concur thread executed.
print('concur.iterations: {}'.format(concur.iterations))

InformationsquelleAutor martineau

4

Die Umsetzung der stop() würde wie folgt Aussehen:
```
def stop(self):
    self.stopped = True
```
Wenn Sie neu starten möchten, dann können Sie einfach eine neue Instanz erstellen und start.
```
while conditon:
    inst = Concur()
    inst.start()

    #after some operation
    inst.stop()
    #some other operation
```
Den Dokumentation für Thread macht deutlich, dass die start() Methode kann nur aufgerufen werden, einmal für jede Instanz der Klasse.

Wenn Sie anhalten möchten, und wieder ein thread, dann werden Sie brauchen, um eine Bedingung variable.
- Es ist in der Schleife, I want to restart es wieder an den Anfang des Codes. Wie kann ich start-beenden-neu starten-beenden-neu starten ?
- seine "Haupt-code" bedeutet den Versuch zu starten, den thread in einer Schleife.
- Sorry, ich bin neu in diesem Ort. Sorry
- wird wait und notify Methoden führen busy-wait ?
- Ich habe getan, def wait(self) : self.wait() und def notify(self): self.notify(). Nach caling warten und dann informieren, Fehler wird ausgegeben "Rekursionstiefe ist zu viel"
- Sie brauchen, um eine Zustand-variable. So, dass Sie nicht ausgelastet warten.
InformationsquelleAutor David Heffernan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.