Kommando wiederholen

[mr.hide]

z.B.: so?

Code: Alles auswählen

import threading
import time


class OwnThread(threading.Thread):
   
    def __init__(self):
        threading.Thread.__init__(self)
        print "Ich bin ein eigener Prozess"

    def run(self):
        while not abbruch_event.isSet():
            print "laufe noch"
            time.sleep(2)
           


abbruch_event = threading.Event()

t = OwnThread()
t.start()

print "Ich bin schon fertig, warte noch und schliesse dann den Thread"

time.sleep(4)
abbruch_event.set()

- Natürlich kanns du die beiden letzten Zeilen auskommentieren, aber dann hast du ne Endlosschleife

Geht natürlich auch noch anders.
Aber hiermit erschaffst du eine Klasse die als neuer Prozess läuft.
Dadurch terminiert sie nicht wenn das Programm das Sie startet zu Ende ist. Ausser du setzt es als Deamon.

[Gast]

Wow, danke!

Ist genau das, was ich wollte!

[Gast]

Ach ja, so sieht jetzt übrigens mein Programmteil aus, falls es jemanden interessiert:

Code: Alles auswählen

import threading
import time

class MyRegularThread(threading.Thread):
	def __init__(self):
		threading.Thread.__init__(self)			
		
	def run(self):
		sleep_time = 60  
		i = 1
		while i == 1:   
			print "does anything"
			time.sleep(sleep_time)
			
t = MyRegularThread()
t.start()	

[BlackJack]

Das `i` kannst'e weglassen und ``while True:`` stattdessen schreiben.

[Gast]

Jo, habs jetzt noch ein bisschen verändert und erweitert - klappt wunderbar!

Danke für eure Hilfe!

Code: Alles auswählen

import threading
import time

class MyRegularThread(threading.Thread):
	def __init__(self):
		threading.Thread.__init__(self)           
		global abbruch_event
		abbruch_event = threading.Event()
	def run(self):
		sleep_time = 2 
		while not abbruch_event.isSet():  
			print "does anything"
			time.sleep(sleep_time)
	def close(self):
		abbruch_event.set()



class MyMainProgram:
	def begin_MyRegularThread(self):
		t = MyRegularThread()
		t.start()   
	def close_MyRegularThread(self):
		t = MyRegularThread()
		t.close()
	def somethingElse(self):
		print "does something else"
		
do = MyMainProgram()
do.begin_MyRegularThread()
do.somethingElse()

time.sleep(10)

do.close_MyRegularThread()
		

[BlackJack]

Jo, habs jetzt noch ein bisschen verändert und erweitert - klappt wunderbar!

Klappt aber nur mit einem Thread.

Code: Alles auswählen

import threading
import time

class MyRegularThread(threading.Thread):
	def __init__(self):
		threading.Thread.__init__(self)           
		global abbruch_event
		abbruch_event = threading.Event()
	def run(self):
		sleep_time = 2 
		while not abbruch_event.isSet():  
			print "does anything"
			time.sleep(sleep_time)
	def close(self):
		abbruch_event.set()

Hier führst Du mit ``global`` ein `abbruch_event` ein, das für das gesamte Modul gilt und nicht nur für den einen Thread.

Code: Alles auswählen

class MyMainProgram:
	def begin_MyRegularThread(self):
		t = MyRegularThread()
		t.start()   
	def close_MyRegularThread(self):
		t = MyRegularThread()
		t.close()
	def somethingElse(self):
		print "does something else"

Hier wird eine Klasse als Namensraum missbraucht. Warum sind die Funktionen nicht auf Modulebene?

In `begin_*` erzeugst Du ein `MyRegularThread` Objekt und startest den Thread. In `close_*` erzeugst Du ein neues `MyRegularThread` Objekt und rufst darauf die `close()` Methode auf. Was nur funktioniert weil `abbruch_event` auf Modulebene und nicht als Instanzvariable existiert.