sowas wie setInterval() -> Thread [gelöst]

[droptix]

BlackJack schrieb hier dieses hübsche Stück Code, als ein Flasher nach sowas wie `setInterval()` fragte:

Code: Alles auswählen

from time import sleep
from threading import Thread

class Counter(Thread):
    def __init__(self, duration, max_count):
        Thread.__init__(self)
        self.duration = duration
        self.max_count = max_count
   
    def run(self):
        for count in xrange(self.max_count):
            print 'counter %s: %d' % (self.getName(), count)
            sleep(self.duration)


def main():
    counter = Counter(0.2, 10)
    counter.start()

Nett, aber ein paar Fragen dazu:

1) Worin besteht genau der Vorteil beim Benutzen von `Thread`? Ich könnte doch auch eine Klasse schreiben, die einfach nur `sleep()` nutzt.
2) in `main()` startest du die Methode `start()`. Gibt's in deiner Counter-Klasse nicht -> ist die von `Thread` geerbt?

Ich brauche auch gerade sowas wie `setInterval()`, das es ja auch bei JavaScript gibt. Es funktioniert so, dass man den Namen einer Funktion und die Verzögerung in Millisekunden angibt. Optional kann man auch noch Parameter an die Funktion überreichen. Flash und JS unterscheiden sich da etwas von der Syntax...

Jedenfalls liefert `setInterval()` eine Ganzzahl zurück, die während der gesamten Laufzeit einmalig ist (also eine ID). Wenn man die Schleife beenden möchte, nutzt man:

Code: Alles auswählen

intervalID = setInterval(trace, 200, this);
// later...
if (condition) {
    clearInterval(intervalID);
}

Dadurch werden der Interval-Prozess beendet und die Speicherressourcen wieder frei gegeben.

Käme es dem gleich, wenn ich nun in der Counter-Klasse ein `self.stop = False` hinzufüge, dass ich irgendwann auf False setze? Ein `max_count` benötige ich nämlich nicht.

[Leonidas]

1) Worin besteht genau der Vorteil beim Benutzen von `Thread`? Ich könnte doch auch eine Klasse schreiben, die einfach nur `sleep()` nutzt.

Ohne Threads wird dabei das ganze Programm begremst, mit Threads nur der eine Thread.

2) in `main()` startest du die Methode `start()`. Gibt's in deiner Counter-Klasse nicht -> ist die von `Thread` geerbt?

Genau: ``start()`` ruft dann ``run()`` selbstständig auf.

[BlackJack]

Code: Alles auswählen

from time import sleep
from threading import Thread

class Counter(Thread):
    def __init__(self, duration, max_count):
        Thread.__init__(self)
        self.duration = duration
        self.max_count = max_count
   
    def run(self):
        for count in xrange(self.max_count):
            print 'counter %s: %d' % (self.getName(), count)
            sleep(self.duration)


def main():
    counter = Counter(0.2, 10)
    counter.start()

Nett, aber ein paar Fragen dazu:

1) Worin besteht genau der Vorteil beim Benutzen von `Thread`? Ich könnte doch auch eine Klasse schreiben, die einfach nur `sleep()` nutzt.

Dazu bräuchte man keine Klasse, da würde eine einfache Funktion reichen. Aber die blockiert dann. Nach `counter.start()` läuft sowohl die `run()`-Methode als auch der Code der nach `counter.start()` kommt, oder kommen würde wenn da was stände, "gleichzeitig". Der Aufruf der `start()`-Methode kehrt sofort zurück.

2) in `main()` startest du die Methode `start()`. Gibt's in deiner Counter-Klasse nicht -> ist die von `Thread` geerbt?

Ja. Die erzeugt einen neuen Thread in dem die `run()`-Methode ausgeführt wird und kehrt dann sofort zum Aufrufer zurück.

Code: Alles auswählen

intervalID = setInterval(trace, 200, this);
// later...
if (condition) {
    clearInterval(intervalID);
}

Dadurch werden der Interval-Prozess beendet und die Speicherressourcen wieder frei gegeben.

Käme es dem gleich, wenn ich nun in der Counter-Klasse ein `self.stop = False` hinzufüge, dass ich irgendwann auf False setze? Ein `max_count` benötige ich nämlich nicht.

Ja, in der `run()`-Methode hättest Du dann eine Schleife die auf `self.stop` prüft. Könnte so aussehen:

Code: Alles auswählen

    def run():
        while not self.stop:
            sleep(self.time)
            self.func(*self.args, **self.kwargs)

[droptix]

Jippiejeah... funzt!