Threading sonlandırma

#1

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

0 Likes

#2

Hata mı aldınız, aldıysanız paylaşabilir misiniz?

0 Likes

#3

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 :blush:

0 Likes

#4

Neden ki? Ben çok seviyorum :slight_smile:

0 Likes

#5

Degil. Ama Thread subclass’i yaratiyorsak ona bir stop() metodu eklemek daha dogru. (4. ornekteki gibi)

  1. Lock objesi paylasilmadigindan dolayi hic bir etkisi olmaz
  2. Paylasilan bir Lock objesi kullanilsa dahi korudugu tek sey bu kodun iki kere ayni anda cagrilmasi olur
  3. Kodda race condition olmadigi icin birden fazla ve/veya eszamanli olarak cagrilmasina karsi korumaya gerek yok
  4. 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.

3 Likes