Cara menghentikan threading python

Ini adalah salah satu pertanyaan yang paling sering diajukan di Python. Jadi, dalam artikel ini, kami akan membahas masalah ini dan memastikan Anda memiliki pemahaman yang jelas tentang topik ini. Sebelum masuk ke topik secara langsung, kita akan melihat threading secara singkat dan kemudian beralih ke pertanyaan kritis misi kita. Jadi tanpa penundaan lebih lanjut, biarkan permainan dimulai. ?

Perkenalan

Apa itu Utas ?

Menurut Wikipedia, dalam ilmu komputer, rangkaian eksekusi adalah urutan terkecil dari instruksi terprogram yang dapat dikelola secara independen oleh penjadwal, yang biasanya merupakan bagian dari sistem operasi.

➽ Banyak utas dapat berjalan secara bersamaan dalam satu program. Misalnya dalam pengolah kata, utas latar belakang dapat digunakan untuk pemeriksaan ejaan sementara utas latar depan dapat digunakan untuk memproses input pengguna (penekanan tombol), sedangkan utas ketiga dapat digunakan untuk memuat gambar dari hard drive, dan

• Oleh karena itu, threading di Python digunakan untuk menjalankan banyak utas yang dapat berupa panggilan tugas atau fungsi, secara bersamaan. Harap perhatikan bahwa ini tidak berarti bahwa banyak utas dijalankan pada CPU yang berbeda
• Utas python tidak membuat program lebih cepat jika sudah menggunakan 100% waktu CPU. Itu mungkin merupakan bagian dari pemrograman paralel yang tidak termasuk dalam ruang lingkup diskusi ini

Catatan. Threading dengan Python itu sendiri merupakan keseluruhan topik diskusi. Tujuan dari pengenalan ini adalah untuk memperkenalkan Anda dengan ide utas. Sangat disarankan agar Anda memiliki pemahaman tentang threading dengan Python sebelum terjun ke topik membunuh utas

➥ Kapan kita menggunakan Threading dengan Python?

Utas dalam Python digunakan dalam situasi di mana pelaksanaan panggilan tugas atau fungsi melibatkan beberapa penantian. Contohnya adalah interaksi dengan layanan yang dihosting di server web. Dengan demikian, threading memungkinkan Python untuk mengeksekusi kode lain sambil menunggu.  

➥ Contoh

import threading
import time

print("Printing values from 90 to 100: ")
def loop_thread():
    for t in range(90, 101):
        time.sleep(1)
        print(t)

threading.Thread(target=loop_thread).start()

Keluaran

Printing values from 90 to 100: 
90
91
92
93
94
95
96
97
98
99
100

_

Sekarang setelah memiliki ikhtisar utas, mari selami pertanyaan kritis misi kita

Cara Membunuh Utas Dengan Python

Sederhananya, membunuh utas secara tiba-tiba adalah praktik yang sangat buruk kecuali benar-benar diperlukan. Karena itu, Anda mungkin ingin mematikan utas setelah durasi waktu tertentu atau setelah beberapa interupsi. Jadi, alih-alih menutupnya secara paksa, Anda dapat dengan ramah meminta utas untuk pergi setelah memastikan pembersihan yang benar

• Utas yang Anda coba matikan mungkin menyimpan sumber daya penting yang harus ditutup dengan benar
• Utas mungkin telah membuat beberapa utas lain yang harus dimatikan juga sebelum utas induk dapat dimatikan

Mari kita pahami berbagai cara yang membantu kita melakukan itu

Metode 1. Membuat Bendera Permintaan Keluar

Jika Anda adalah pengelola utas Anda sendiri, cara yang baik untuk menangani penghentian utas adalah dengan membuat bendera keluar yang diperiksa setiap utas secara berkala untuk mengetahui apakah sudah waktunya untuk keluar

Contoh

import threading 
import time 
  
def thread_foo(stop):
    while True: 
        print("THREAD STILL RUNNING!") 
        if exit_flag: 
            break

exit_flag = False
t = threading.Thread(target = thread_foo, args =(lambda : exit_flag, )) 
t.start() 
time.sleep(0.1) 
print('Done sleeping! Time to stop the threads.')
exit_flag = True
t.join() 
print('THREAD TERMINATED!')

Keluaran

Dalam contoh di atas, kami membuat fungsi yang terus menjalankan utas hingga program menemukan variabel

Printing values from 90 to 100: 
90
91
92
93
94
95
96
97
98
99
100

2. Segera setelah itu terjadi, utas dapat dimatikan menggunakan metode

Printing values from 90 to 100: 
90
91
92
93
94
95
96
97
98
99
100

3

➥ Catatan.

Printing values from 90 to 100: 
90
91
92
93
94
95
96
97
98
99
100

4 menyebabkan utas utama menunggu utas Anda selesai dieksekusi. Dengan kata lain,

Printing values from 90 to 100: 
90
91
92
93
94
95
96
97
98
99
100

4 bertindak sebagai "penahan" di utas utama. Ini memastikan bahwa utas Anda telah menyelesaikan eksekusinya sebelum utas utama dapat bergerak maju. Di satu sisi, ini memastikan pemutusan utas Anda yang bersih dan tepat.

Metode 2. Menggunakan Multiproses Modul

Sebagaimana dinyatakan dalam dokumentasi Python,  adalah paket yang mendukung proses pemijahan menggunakan API yang mirip dengan modul 

Printing values from 90 to 100: 
90
91
92
93
94
95
96
97
98
99
100

7 . Selain itu, membunuh proses jauh lebih aman daripada membunuh utas karena utas berbagi variabel global dan memiliki ketergantungan, sedangkan proses sepenuhnya independen dan terpisah satu sama lain. Modul multiprocessing_ memiliki fungsi

Printing values from 90 to 100: 
90
91
92
93
94
95
96
97
98
99
100

9 yang digunakan untuk menghentikan proses

Mari kita lihat contoh berikut yang diberikan di bawah ini untuk memahami bagaimana kita dapat menggunakan modul multiprocessing untuk mematikan proses

import multiprocessing
import time
def Child_process():
  while True:
   for i in range (20):  
    print ('Process: ', i)
    time.sleep(0.05)
t = multiprocessing.Process(target = Child_process)
t.start()
time.sleep(0.5)
t.terminate()
print("Child Process successfully terminated")

_

Keluaran

Process:  0
Process:  1
Process:  2
Process:  3
Process:  4
Process:  5
Process:  6
Process:  7
Process:  8
Process:  9
Child Process successfully terminated

Dalam contoh di atas setelah 0. 5 detik eksekusi

import threading 
import time 
  
def thread_foo(stop):
    while True: 
        print("THREAD STILL RUNNING!") 
        if exit_flag: 
            break

exit_flag = False
t = threading.Thread(target = thread_foo, args =(lambda : exit_flag, )) 
t.start() 
time.sleep(0.1) 
print('Done sleeping! Time to stop the threads.')
exit_flag = True
t.join() 
print('THREAD TERMINATED!')

_1 dihentikan menggunakan fungsi

import threading 
import time 
  
def thread_foo(stop):
    while True: 
        print("THREAD STILL RUNNING!") 
        if exit_flag: 
            break

exit_flag = False
t = threading.Thread(target = thread_foo, args =(lambda : exit_flag, )) 
t.start() 
time.sleep(0.1) 
print('Done sleeping! Time to stop the threads.')
exit_flag = True
t.join() 
print('THREAD TERMINATED!')

2

Metode 3. Menggunakan Modul jejak

Pendekatan lain untuk membunuh utas adalah menginstal

Printing values from 90 to 100: 
90
91
92
93
94
95
96
97
98
99
100

0 ke dalam utas yang akan keluar dari utas.  

Modul yang diberikan di bawah ini memungkinkan Anda untuk mematikan utas. Kelas

import threading 
import time 
  
def thread_foo(stop):
    while True: 
        print("THREAD STILL RUNNING!") 
        if exit_flag: 
            break

exit_flag = False
t = threading.Thread(target = thread_foo, args =(lambda : exit_flag, )) 
t.start() 
time.sleep(0.1) 
print('Done sleeping! Time to stop the threads.')
exit_flag = True
t.join() 
print('THREAD TERMINATED!')

_4 adalah pengganti drop-in untuk

import threading 
import time 
  
def thread_foo(stop):
    while True: 
        print("THREAD STILL RUNNING!") 
        if exit_flag: 
            break

exit_flag = False
t = threading.Thread(target = thread_foo, args =(lambda : exit_flag, )) 
t.start() 
time.sleep(0.1) 
print('Done sleeping! Time to stop the threads.')
exit_flag = True
t.join() 
print('THREAD TERMINATED!')

5. Itu menambahkan metode

import threading 
import time 
  
def thread_foo(stop):
    while True: 
        print("THREAD STILL RUNNING!") 
        if exit_flag: 
            break

exit_flag = False
t = threading.Thread(target = thread_foo, args =(lambda : exit_flag, )) 
t.start() 
time.sleep(0.1) 
print('Done sleeping! Time to stop the threads.')
exit_flag = True
t.join() 
print('THREAD TERMINATED!')

6, yang seharusnya menghentikan sebagian besar utas di jalurnya

Penafian. Prosedur yang diberikan di bawah ini diambil dari sumber berikut. Bunuh utas dengan Python

KThread. py. Implementasi Thread yang bisa dimatikan

import time
import sys
import trace
import threading

class KThread(threading.Thread):
  """A subclass of threading.Thread, with a kill()
method."""
  def __init__(self, *args, **keywords):
    threading.Thread.__init__(self, *args, **keywords)
    self.killed = False

  def start(self):
    """Start the thread."""
    self.__run_backup = self.run
    self.run = self.__run     
    threading.Thread.start(self)

  def __run(self):
    """Hacked run function, which installs the
trace."""
    sys.settrace(self.globaltrace)
    self.__run_backup()
    self.run = self.__run_backup

  def globaltrace(self, frame, why, arg):
    if why == 'call':
      return self.localtrace
    else:
      return None

  def localtrace(self, frame, why, arg):
    if self.killed:
      if why == 'line':
        raise SystemExit()
    return self.localtrace

  def kill(self):
    self.killed = True


# Example Usage
#This illustrates running a function in a separate thread. The thread is killed before the function finishes.
def func():
  print('Function started')
  for i in range(1,100):
    print(i)
    time.sleep(0.2)
  print('Function finished')

A = KThread(target=func)
A.start()
time.sleep(1)
A.kill()

Keluaran

Function started
1
2
3
4
5

Metode 4. Menggunakan ctypes Untuk Menaikkan Pengecualian Dalam Rangkaian

Dalam kasus ketika Anda perlu mematikan utas secara paksa, misalnya, saat membungkus pustaka eksternal yang sibuk untuk panggilan lama dan Anda ingin menghentikannya, Anda dapat menggunakan raise_exc() untuk memunculkan pengecualian arbitrer, atau memanggil terminasi() untuk . Ini menggunakan fungsi PyThreadState_SetAsyncExc yang tidak diekspos (melalui ctypes) untuk memunculkan pengecualian dalam konteks utas yang diberikan.  

Kode berikut memungkinkan (dengan beberapa batasan) untuk menaikkan Pengecualian di utas Python

Contoh

import threading
import inspect
import ctypes
import time


def _async_raise(tid, exctype):
    """raises the exception, performs cleanup if needed"""
    if not inspect.isclass(exctype):
        raise TypeError("Only types can be raised (not instances)")
    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid), ctypes.py_object(exctype))
    if res == 0:
        raise ValueError("invalid thread id")
    elif res != 1:
        # """if it returns a number greater than one, you're in trouble, 
        # and you should call it again with exc=NULL to revert the effect"""
        ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
        raise SystemError("PyThreadState_SetAsyncExc failed")


class Thread(threading.Thread):
    def _get_my_tid(self):
        """determines this (self's) thread id"""
        if not self.is_alive():
            raise threading.ThreadError("the thread is not active")
        
        # do we have it cached?
        if hasattr(self, "_thread_id"):
            return self._thread_id
        
        # no, look for it in the _active dict
        for tid, tobj in threading._active.items():
            if tobj is self:
                self._thread_id = tid
                return tid
        
        raise AssertionError("could not determine the thread's id")
    
    def raise_exc(self, exctype):
        """raises the given exception type in the context of this thread"""
        _async_raise(self._get_my_tid(), exctype)
    
    def terminate(self):
        """raises SystemExit in the context of the given thread, which should 
        cause the thread to exit silently (unless caught)"""
        self.raise_exc(SystemExit)

def f():
     try:
         while True:
            for i in range(10000):
             print(i) 
             time.sleep(0.1)
     finally:
         print ("TERMINATING!!!")

t = Thread(target = f)
t.start()
time.sleep(0.6)
t.terminate()
t.join()

Keluaran

0
1
2
3
4
5
TERMINATING!!!

Kesimpulan

Kesimpulan utama dari artikel ini adalah

• Apa itu Benang?
• Cara untuk mematikan utas dengan Python
  • Membuat bendera Exit_Request
  • Menggunakan

    import threading 
    import time 
      
    def thread_foo(stop):
        while True: 
            print("THREAD STILL RUNNING!") 
            if exit_flag: 
                break
    
    exit_flag = False
    t = threading.Thread(target = thread_foo, args =(lambda : exit_flag, )) 
    t.start() 
    time.sleep(0.1) 
    print('Done sleeping! Time to stop the threads.')
    exit_flag = True
    t.join() 
    print('THREAD TERMINATED!')

    _7Modul
  • Menggunakan

    Printing values from 90 to 100: 
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100

    _0Modul
  • Menggunakan

    Printing values from 90 to 100: 
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100

    _1untuk meningkatkan Pengecualian di utas

Silakan berlangganan dan nantikan artikel-artikel menarik lainnya

Referensi

1. https. //stackoverflow. com/questions/323972/is-there-any-cara-to-kill-a-thread
2. http. //informasi-net. com/python/iq/kill. htm
3. https. //pybay. com/site_media/slides/raymond2017-keynote/threading. html
4. http. //tomerfilib. com/resep/Utas2/

Humor Nerd

Oh ya, saya bahkan tidak tahu mereka menamainya Menara Willis pada tahun 2009, karena saya tahu banyak tentang gedung pencakar langit. — xkcd (sumber)

Kemana Pergi Dari Sini?

Cukup teori. Mari kita berlatih

Pembuat kode dibayar enam digit atau lebih karena mereka dapat memecahkan masalah dengan lebih efektif menggunakan kecerdasan mesin dan otomasi

Untuk menjadi lebih sukses dalam pengkodean, selesaikan lebih banyak masalah nyata untuk orang-orang nyata. Begitulah cara Anda memoles keterampilan yang benar-benar Anda butuhkan dalam latihan. Lagi pula, apa gunanya teori belajar yang tidak dibutuhkan siapa pun?

Anda membangun keterampilan pengkodean bernilai tinggi dengan mengerjakan proyek pengkodean praktis

Apakah Anda ingin berhenti belajar dengan proyek mainan dan fokus pada proyek kode praktis yang memberi Anda uang dan memecahkan masalah nyata bagi orang-orang?

🚀 Jika jawaban Anda adalah YA. , pertimbangkan untuk menjadi pengembang lepas Python. Ini adalah cara terbaik untuk mendekati tugas meningkatkan keterampilan Python Anda—bahkan jika Anda benar-benar pemula

Jika Anda hanya ingin belajar tentang peluang freelancing, jangan ragu untuk menonton webinar gratis saya “Bagaimana Membangun Keterampilan Berpenghasilan Tinggi Anda Python” dan pelajari bagaimana saya mengembangkan bisnis coding saya secara online dan bagaimana Anda juga bisa—dari kenyamanan Anda

Bergabunglah dengan webinar gratis sekarang

Shubham Sayon

Saya seorang Blogger Python profesional dan pembuat Konten. Saya telah menerbitkan banyak artikel dan membuat kursus selama periode waktu tertentu. Saat ini saya bekerja sebagai pekerja lepas penuh waktu dan saya memiliki pengalaman dalam domain seperti Python, AWS, DevOps, dan Networking

Bagaimana cara menghentikan threading?

Bagaimana cara menghentikan dan memulai kembali utas dengan Python?