iki tane fonk tanimladim birisini threading ile calisdiriyorum diyerini normal, normal calisdirdigim fonk icinden threading ile calisani sonlandirmaya calisiyorum ama olmuyor fonk iceriyin onemi yok ne olursa olsun bir turlu sonlandiramadim.Yardimci olurmusunuz
Hata mı aldınız, aldıysanız paylaşabilir misiniz?
Merhaba @Efrahim ,
import time
from threading import Thread, Lock
class myThread(Thread):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.running = True
def run(self):
while self.running:
[...]
# work
[...]
my_thread = myThread()
my_thread.start()
time.sleep(5)
my_thread.running = False
Bu yöntem bana sağlıksız gibi geldi. Belki şu şekilde daha sağlıklı olur:
import time
from threading import Thread, Lock
class myThread(Thread):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.running = True
def run(self):
while self.running:
[...]
# work
[...]
my_thread = myThread()
my_thread.start()
time.sleep(5)
lock = Lock()
lock.acquire()
my_thread.running = False
lock.release()
Bu şekilde veriler daha sağlıklı yazılır ve okunur diye biliyorum. Ama bir lise 3 öğrencisi olarak Thread hakkında daha kırk fırın ekmek yemem lazım. Ayrıca threadlerden nefret ediyorum, ama bazen kullanmak gerekiyor.
Bunu hiç deneme fırsatım olmadı, ama şunu da deneyebilirsin:
Bir threadi başka thread üzerinden kapatmak…
import time
from threading import Thread, Lock
class myThread(Thread):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.running = True
def run(self):
while self.running:
[...]
# work
[...]
def stop_thread(thread):
thread.running = False
my_thread = myThread()
my_stopper_thread = Thread(target= stop_thread, my_thread)
my_thread.start()
time.sleep(5)
my_stopper_thread.start() # durdurucu thread çalıştığında my_thread adlı thread çalışmaz, böylece veri güvenliği sağlanır diye düşündüm, ama bu düşüncenin yanlış olduğuna sonradan farkına vardım
Sana verebileceğim en sağlıklı mekanizma:
import time
from threading import Thread, Event
class myThread(Thread):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.running_event = Event()
def run(self):
while not self.running_event.isSet():
[...]
# work
[...]
def stop_thread(self):
self.running_event.set()
my_thread = myThread()
my_thread.start()
time.sleep(5)
my_thread.stop_thread()
Event
leri ve Lock
ları incelemeni öneririm.
Hatta Semaphore
yi de incele, ama onu daha anlayabilmiş değilim.
Kolay gelsin
Neden ki? Ben çok seviyorum
Degil. Ama Thread subclass’i yaratiyorsak ona bir stop()
metodu eklemek daha dogru. (4. ornekteki gibi)
- Lock objesi paylasilmadigindan dolayi hic bir etkisi olmaz
- Paylasilan bir Lock objesi kullanilsa dahi korudugu tek sey bu kodun iki kere ayni anda cagrilmasi olur
- Kodda race condition olmadigi icin birden fazla ve/veya eszamanli olarak cagrilmasina karsi korumaya gerek yok
run
’i da icine alacak sekilde butun koda bakarsak burada da race condition yok, dolayisiyla herhangi bir senkronizasyon yontemine de gerek yok
Event set edildiginde kod duracagi icin stop_event
daha mantikli bir isim olur. Ama onun disinda event kullanmanin en dogru cozum olduguna katiliyorum, ozellikle disariya acilacaksa. (boolean’i bir fonksiyona parametre olarak paslayamayiz ama event’i paslayabiliriz)
Semaphore’u ayni anda N kere kitlenebilen lock olarak dusunebilirsin. Veya sirayla denenen N tane lock olarak.