Multithread masuk Python dengan Contoh: Pelajari GIL di Python

The Python Bahasa pemrograman memungkinkan Anda untuk menggunakan multiprocessing atau multithreading. Dalam tutorial ini, Anda akan mempelajari cara menulis aplikasi multithreaded di Python.

Apa itu Benang?

Thread adalah unit eksekusi dalam pemrograman konkuren. Multithreading adalah teknik yang memungkinkan CPU untuk mengeksekusi banyak tugas dari satu proses secara bersamaan. Thread-thread ini dapat dieksekusi secara individual sambil berbagi sumber daya prosesnya.

Apa itu Proses?

Pada dasarnya, sebuah proses adalah program yang sedang dieksekusi. Saat Anda menjalankan aplikasi di komputer Anda (seperti browser atau editor teks), sistem operasi akan membuat sebuah proses. proses.

Apa itu Multithreading Python?

Multithread masuk Python Pemrograman multithreading adalah teknik yang terkenal di mana beberapa thread dalam suatu proses berbagi ruang data mereka dengan thread utama, yang membuat berbagi informasi dan komunikasi antar thread menjadi mudah dan efisien. Thread lebih ringan daripada proses. Beberapa thread dapat dieksekusi secara individual sambil berbagi sumber daya proses mereka. Tujuan multithreading adalah untuk menjalankan beberapa tugas dan fungsi secara bersamaan.

Apa itu Multiprosesor?

Multiprosesor memungkinkan Anda menjalankan beberapa proses yang tidak terkait secara bersamaan. Proses-proses ini tidak berbagi sumber daya dan berkomunikasi melalui IPC.

Python Multithreading vs Multiprosesing

Untuk memahami proses dan thread, pertimbangkan skenario ini: Sebuah file .exe di komputer Anda adalah sebuah program. Saat Anda membukanya, sistem operasi memuatnya ke dalam memori, dan CPU mengeksekusinya. Instans program yang sedang berjalan disebut proses.

Setiap proses memiliki dua komponen mendasar:

• The Code
• Data

Sekarang, suatu proses dapat berisi satu atau lebih sub-bagian yang disebut utas. Hal ini bergantung pada arsitektur sistem operasi. Anda dapat menganggap thread sebagai bagian dari proses yang dapat dieksekusi secara terpisah oleh sistem operasi.

Dengan kata lain, ini adalah aliran instruksi yang dapat dijalankan secara independen oleh sistem operasi. Thread dalam satu proses berbagi data proses tersebut dan dirancang untuk bekerja sama guna memfasilitasi paralelisme.

Mengapa menggunakan Multithreading?

Multithreading memungkinkan Anda memecah aplikasi menjadi beberapa subtugas dan menjalankan tugas-tugas ini secara bersamaan. Jika Anda menggunakan multithreading dengan benar, kecepatan, kinerja, dan rendering aplikasi Anda dapat ditingkatkan.

Python multithreading

Python Mendukung konstruksi untuk multiprocessing dan multithreading. Dalam tutorial ini, Anda akan fokus terutama pada implementasi multithread aplikasi dengan PythonTerdapat dua modul utama yang dapat digunakan untuk menangani thread di Python:

1. The benang modul, dan
2. The threading modul

Namun, di PythonSelain itu, ada juga yang disebut global interpreter lock (GIL). GIL tidak memberikan banyak peningkatan kinerja dan bahkan mungkin malah menurunkan performa. menurunkan kinerja beberapa aplikasi multithread. Anda akan mempelajari semuanya di bagian selanjutnya dari tutorial ini.

Modul Thread dan Threading

Dua modul yang akan Anda pelajari dalam tutorial ini adalah modul benang dan modul penguliran.

Namun, modul thread sudah lama tidak digunakan lagi. Dimulai dengan Python 3, telah ditetapkan sebagai usang dan hanya dapat diakses sebagai _benang untuk kompatibilitas mundur.

Anda harus menggunakan level yang lebih tinggi threading Modul untuk aplikasi yang ingin Anda sebarkan. Modul thread hanya dibahas di sini untuk tujuan edukasi.

Modul Benang

Sintaks untuk membuat thread baru menggunakan modul ini adalah sebagai berikut:

thread.start_new_thread(function_name, arguments)

Baiklah, sekarang Anda telah membahas teori dasar untuk memulai coding. Jadi, buka milikmu IDLE atau gunakan notepad dan ketik yang berikut ini:

import time
import _thread

def thread_test(name, wait):
   i = 0
   while i <= 3:
      time.sleep(wait)
      print("Running %s\n" %name)
      i = i + 1

   print("%s has finished execution" %name)

if __name__ == "__main__":
    
    _thread.start_new_thread(thread_test, ("First Thread", 1))
    _thread.start_new_thread(thread_test, ("Second Thread", 2))
    _thread.start_new_thread(thread_test, ("Third Thread", 3))

Simpan file dan tekan F5 untuk menjalankan program. Jika semuanya dilakukan dengan benar, inilah output yang akan Anda lihat:

Anda akan mempelajari lebih lanjut tentang kondisi balapan dan cara menanganinya di bagian selanjutnya.

PENJELASAN KODE

1. Pernyataan-pernyataan ini mengimpor modul waktu dan thread, yang digunakan untuk menangani eksekusi dan penundaan. Python utas.
2. Di sini, Anda telah mendefinisikan fungsi yang dipanggil uji_utas, yang akan dipanggil oleh mulai_utas_baru Metode ini menjalankan perulangan while selama empat iterasi dan mencetak nama thread yang memanggilnya. Setelah iterasi selesai, ia mencetak pesan yang menyatakan bahwa thread telah selesai dieksekusi.
3. Ini adalah bagian utama dari program Anda. Di sini, Anda cukup menelepon mulai_utas_baru metode dengan thread_test Fungsi ini akan dibuat sebagai argumen. Ini akan membuat thread baru untuk fungsi yang Anda berikan sebagai argumen dan mulai mengeksekusinya. Perhatikan bahwa Anda dapat mengganti ini (thread_test) dengan fungsi lain apa pun yang ingin Anda jalankan sebagai thread.

Modul Penguliran

Modul ini adalah implementasi tingkat tinggi dari threading di Python dan merupakan standar de facto untuk mengelola aplikasi multithread. Modul ini menyediakan berbagai fitur yang lebih luas dibandingkan modul thread.

Struktur modul Threading

Berikut adalah daftar beberapa fungsi berguna yang didefinisikan dalam modul ini:

Latar Belakang: Kelas Thread

Sebelum Anda mulai membuat program multithread menggunakan modul threading, sangat penting untuk memahami kelas Thread. Kelas thread adalah kelas utama yang mendefinisikan template dan operasi sebuah thread. Python.

Cara paling umum untuk membuat multithreaded Python Tujuan aplikasinya adalah untuk mendeklarasikan sebuah kelas yang memperluas kelas Thread dan menimpa metode run() miliknya.

Kelas Thread, secara ringkas, menandakan urutan kode yang berjalan secara terpisah benang kontrol.

Jadi, saat menulis aplikasi multithread, Anda akan melakukan hal berikut:

1. mendefinisikan kelas yang memperluas kelas Thread
2. Ganti __init__ pembina
3. Ganti Lari() metode

Setelah objek thread dibuat, Mulailah() Metode ini dapat digunakan untuk memulai pelaksanaan aktivitas ini, dan Ikuti() metode dapat digunakan untuk memblokir semua kode lainnya hingga aktivitas saat ini selesai.

Sekarang, mari kita coba menggunakan modul threading untuk mengimplementasikan contoh Anda sebelumnya. Sekali lagi, jalankan program Anda. IDLE dan ketik yang berikut ini:

import time
import threading

class threadtester (threading.Thread):
    def __init__(self, id, name, i):
       threading.Thread.__init__(self)
       self.id = id
       self.name = name
       self.i = i
       
    def run(self):
       thread_test(self.name, self.i, 5)
       print ("%s has finished execution " %self.name)

def thread_test(name, wait, i):

    while i:
       time.sleep(wait)
       print ("Running %s \n" %name)
       i = i - 1

if __name__=="__main__":
    thread1 = threadtester(1, "First Thread", 1)
    thread2 = threadtester(2, "Second Thread", 2)
    thread3 = threadtester(3, "Third Thread", 3)

    thread1.start()
    thread2.start()
    thread3.start()

    thread1.join()
    thread2.join()
    thread3.join()

Ini akan menjadi output ketika Anda menjalankan kode di atas:

PENJELASAN KODE

1. Bagian ini sama dengan contoh kita sebelumnya. Di sini, Anda mengimpor modul waktu dan thread, yang digunakan untuk menangani eksekusi dan penundaan. Python utas.
2. Dalam bit ini, Anda membuat kelas bernama threadtester, yang mewarisi atau memperluas Benang kelas modul threading. Ini adalah salah satu cara paling umum untuk membuat thread di PythonNamun, Anda hanya perlu menimpa konstruktor dan Lari() metode di aplikasi Anda. Seperti yang Anda lihat pada contoh kode di atas, __init__ metode (konstruktor) telah diganti. Demikian pula, Anda juga telah menggantinya Lari() metode. Ini berisi kode yang ingin Anda jalankan di dalam thread. Dalam contoh ini, Anda memanggil fungsi thread_test().
3. Ini adalah metode thread_test(), yang mengambil nilai dari i Sebagai argumen, ia mengurangi i sebesar 1 pada setiap iterasi, dan mengulang sisa kode hingga i menjadi 0. Pada setiap iterasi, ia mencetak nama thread yang sedang dieksekusi dan tidur selama wait detik (yang juga diambil sebagai argumen).
4. thread1 = threadtester(1, “First Thread”, 1) Di sini, kita membuat thread dan meneruskan tiga parameter yang kita deklarasikan di __init__. Parameter pertama adalah id thread, parameter kedua adalah nama thread, dan parameter ketiga adalah counter, yang menentukan berapa kali perulangan while harus dijalankan.
5. thread2.start() Metode start digunakan untuk memulai eksekusi sebuah thread. Secara internal, fungsi start() memanggil metode run() dari kelas Anda.
6. thread3.join() Metode join() memblokir eksekusi kode lain dan menunggu hingga thread yang dipanggil selesai.

Seperti yang sudah Anda ketahui, thread yang berada dalam proses yang sama memiliki akses ke memori dan data proses tersebut. Akibatnya, jika lebih dari satu thread mencoba mengubah atau mengakses data secara bersamaan, kesalahan mungkin akan terjadi.

Pada bagian selanjutnya, Anda akan melihat berbagai jenis komplikasi yang dapat muncul ketika thread mengakses data dan bagian kritis tanpa memeriksa transaksi akses yang sudah ada.

Kebuntuan dan Kondisi Balapan

Sebelum mempelajari tentang deadlock dan race condition, ada baiknya memahami beberapa definisi dasar yang terkait dengan pemrograman konkuren:

• Bagian penting: Ini adalah bagian kode yang mengakses atau memodifikasi variabel bersama dan harus dijalankan sebagai transaksi atomik.
• Pengalihan Konteks: Ini adalah proses yang diikuti CPU untuk menyimpan status sebuah thread sebelum beralih dari satu tugas ke tugas lain sehingga dapat dilanjutkan dari titik yang sama di kemudian hari.

Kebuntuan

Kebuntuan merupakan masalah yang paling ditakuti oleh pengembang saat menulis aplikasi konkuren/multithreaded. PythonCara terbaik untuk memahami deadlock adalah dengan menggunakan contoh masalah ilmu komputer klasik yang dikenal sebagai... Makan PhiloMasalah sopher.

Pernyataan masalah bagi para filsuf makan adalah sebagai berikut:

Lima filsuf duduk di meja bundar dengan lima piring spageti (sejenis pasta) dan lima garpu, seperti yang ditunjukkan pada diagram.

Makan PhiloMasalah sopher

Pada waktu tertentu, seorang filsuf pasti sedang makan atau berpikir.

Selain itu, seorang filsuf harus mengambil dua garpu yang bersebelahan dengannya (yaitu garpu kiri dan kanan) sebelum ia dapat memakan spageti. Masalah kebuntuan terjadi ketika kelima filsuf mengambil garpu kanan mereka secara bersamaan.

Karena setiap filsuf memiliki satu garpu, mereka semua akan menunggu yang lain meletakkan garpu mereka. Akibatnya, tidak ada satu pun dari mereka yang bisa makan spageti.

Demikian pula, dalam sistem konkuren, kebuntuan terjadi ketika beberapa thread atau proses (filosofer) mencoba memperoleh sumber daya sistem bersama (fork) pada saat yang sama. Akibatnya, tidak ada proses yang mendapat kesempatan untuk mengeksekusi karena mereka menunggu sumber daya lain yang dimiliki oleh proses lain.

Kondisi Balapan

Kondisi balapan (race condition) adalah keadaan yang tidak diinginkan dalam sebuah program yang terjadi ketika sistem melakukan dua atau lebih operasi secara bersamaan. Misalnya, perhatikan perulangan for sederhana ini:

i=0; # a global variable
for x in range(100):
    print(i)
    i+=1;

Jika Anda membuat n Dengan banyaknya thread yang menjalankan kode ini secara bersamaan, Anda tidak dapat menentukan nilai i (yang digunakan bersama oleh thread) ketika program selesai dieksekusi. Hal ini karena dalam lingkungan multithreading yang sebenarnya, thread dapat saling tumpang tindih, dan nilai i yang diambil dan dimodifikasi oleh suatu thread dapat berubah di antara waktu ketika thread lain mengaksesnya.

Ini adalah dua kelas utama masalah yang dapat terjadi dalam lingkungan multithreaded atau terdistribusi. Python aplikasi. Di bagian selanjutnya, Anda akan mempelajari cara mengatasi masalah ini dengan menyinkronkan thread.

Syncbenang kronis

Untuk menangani kondisi balapan, kebuntuan, dan masalah berbasis utas lainnya, modul threading menyediakan Mengunci objek. Idenya adalah bahwa ketika sebuah thread ingin mengakses sumber daya tertentu, ia memperoleh kunci untuk sumber daya tersebut. Setelah sebuah thread mengunci sumber daya tertentu, tidak ada thread lain yang dapat mengaksesnya hingga kunci tersebut dilepaskan. Akibatnya, perubahan pada sumber daya akan bersifat atomik, dan kondisi persaingan akan dihindari.

Kunci adalah primitif sinkronisasi tingkat rendah yang diterapkan oleh _benang modul. Pada waktu tertentu, sebuah kunci dapat berada dalam salah satu dari dua keadaan: terkunci or tidak terkunci. Ini mendukung dua metode:

1. mendapatkan(): Ketika status penguncian tidak terkunci, memanggil metode acquire() akan mengubah status menjadi terkunci dan kemudian kembali. Namun, jika status terkunci, panggilan ke acquire() akan diblokir hingga metode release() dipanggil oleh thread lain.
2. melepaskan(): Metode rilis() digunakan untuk mengatur keadaan menjadi tidak terkunci, yaitu untuk melepaskan kunci. Itu bisa dipanggil oleh thread apa pun, belum tentu thread yang memperoleh kuncinya.

Berikut contoh penggunaan kunci di aplikasi Anda. Jalankan aplikasi Anda. IDLE dan ketik yang berikut ini:

import threading
lock = threading.Lock()

def first_function():
    for i in range(5):
        lock.acquire()
        print ('lock acquired')
        print ('Executing the first funcion')
        lock.release()

def second_function():
    for i in range(5):
        lock.acquire()
        print ('lock acquired')
        print ('Executing the second funcion')
        lock.release()

if __name__=="__main__":
    thread_one = threading.Thread(target=first_function)
    thread_two = threading.Thread(target=second_function)

    thread_one.start()
    thread_two.start()

    thread_one.join()
    thread_two.join()

Sekarang, tekan F5. Anda akan melihat keluaran seperti ini:

PENJELASAN KODE

1. Di sini, Anda cukup membuat kunci baru dengan memanggil threading.Kunci() fungsi pabrik. Secara internal, Lock() mengembalikan sebuah instance dari kelas Lock beton paling efektif yang dikelola oleh platform.
2. Pada pernyataan pertama, Anda memperoleh kunci dengan memanggil metode acquire(). Ketika kunci telah diberikan, Anda mencetak “kunci diperoleh” ke konsol. Setelah semua kode yang ingin dijalankan thread telah selesai dieksekusi, lepaskan kunci dengan memanggil metode rilis().

Teorinya bagus, tetapi bagaimana Anda tahu bahwa penguncian benar-benar berhasil? Jika Anda melihat outputnya, Anda akan melihat bahwa setiap pernyataan print mencetak tepat satu baris pada satu waktu. Ingatlah bahwa, dalam contoh sebelumnya, output dari print tidak beraturan karena beberapa thread mengakses metode print() secara bersamaan. Di sini, fungsi print dipanggil hanya setelah penguncian diperoleh. Jadi, output ditampilkan satu per satu dan baris demi baris.

Selain gembok, Python juga mendukung beberapa mekanisme lain untuk menangani sinkronisasi thread, seperti yang tercantum di bawah ini:

1. RKunci
2. Semaphores
3. Kondisi
4. Acara, dan
5. Hambatan

Global Interpreter Lock (dan cara mengatasinya)

Sebelum masuk ke rinciannya PythonDalam GIL, mari kita definisikan beberapa istilah yang akan berguna dalam memahami bagian selanjutnya:

1. Kode yang terikat CPU: ini mengacu pada setiap bagian kode yang akan dieksekusi langsung oleh CPU.
2. Kode yang terikat pada I/O: ini bisa berupa kode apa pun yang mengakses sistem file melalui sistem operasi.
3. CPython: itu adalah referensi implementasi of Python dan dapat digambarkan sebagai penerjemah yang ditulis dalam C dan Python (bahasa pemrograman).

Apa itu GIL Python?

Kunci Penerjemah Global (GIL) in Python GIL adalah pengunci proses atau mutex yang digunakan saat menangani proses. Ini memastikan bahwa hanya satu thread yang dapat mengakses sumber daya tertentu pada satu waktu, dan juga mencegah penggunaan objek dan bytecode secara bersamaan. Hal ini menguntungkan program single-threaded dengan peningkatan kinerja. GIL di Python sangat sederhana dan mudah diterapkan.

Kunci dapat digunakan untuk memastikan bahwa hanya satu thread yang memiliki akses ke sumber daya tertentu pada waktu tertentu.

Salah satu fitur dari Python Hal ini karena menggunakan kunci global pada setiap proses interpreter, yang berarti bahwa setiap proses memperlakukan Python menafsirkan dirinya sendiri sebagai sumber daya.

Misalnya, anggaplah Anda telah menulis sebuah Python Program yang menggunakan dua thread untuk melakukan operasi CPU dan I/O. Saat Anda menjalankan program ini, inilah yang terjadi:

1. The Python Penerjemah membuat proses baru dan menjalankan thread.
2. Saat thread-1 mulai berjalan, thread-XNUMX akan memperoleh GIL terlebih dahulu dan menguncinya.
3. Jika thread-2 ingin dijalankan sekarang, ia harus menunggu hingga GIL dirilis meskipun prosesor lain tersedia.
4. Sekarang, misalkan thread-1 sedang menunggu operasi I/O. Pada saat ini, thread-2 akan melepaskan GIL, dan thread-XNUMX akan memperolehnya.
5. Setelah menyelesaikan operasi I/O, jika thread-1 ingin dijalankan sekarang, thread-2 harus menunggu lagi hingga GIL dirilis oleh thread-XNUMX.

Oleh karena itu, hanya satu thread yang dapat mengakses interpreter pada satu waktu, yang berarti hanya akan ada satu thread yang mengeksekusi. Python kode pada titik waktu tertentu.

Hal ini tidak masalah pada prosesor inti tunggal karena akan menggunakan pembagian waktu (lihat bagian pertama tutorial ini) untuk menangani thread. Namun, dalam kasus prosesor multi-inti, fungsi yang terikat CPU yang dieksekusi pada banyak thread akan berdampak cukup besar pada efisiensi program karena sebenarnya tidak akan menggunakan semua inti yang tersedia secara bersamaan.

Mengapa GIL dibutuhkan?

CPython Pengumpul sampah (garbage collector) menggunakan teknik manajemen memori yang efisien yang dikenal sebagai penghitungan referensi. Begini cara kerjanya: Setiap objek dalam Python Suatu objek memiliki penghitung referensi, yang akan bertambah ketika referensi tersebut diberikan ke nama variabel baru atau ditambahkan ke dalam kontainer (seperti tuple, list, dll.). Demikian pula, penghitung referensi akan berkurang ketika referensi tersebut keluar dari cakupan atau ketika pernyataan `del` dipanggil. Ketika penghitung referensi suatu objek mencapai 0, objek tersebut akan dikumpulkan oleh garbage collector, dan memori yang dialokasikan akan dibebaskan.

Namun masalahnya adalah variabel penghitung referensi rentan terhadap kondisi persaingan (race condition) seperti variabel global lainnya. Untuk mengatasi masalah ini, para pengembang Python Kami memutuskan untuk menggunakan kunci interpreter global. Pilihan lainnya adalah menambahkan kunci ke setiap objek, yang akan mengakibatkan kebuntuan dan peningkatan beban kerja dari panggilan acquire() dan release().

Oleh karena itu, GIL merupakan batasan yang signifikan untuk multithreading. Python Program yang menjalankan operasi yang sangat bergantung pada CPU (secara efektif menjadikannya single-threaded). Jika Anda ingin menggunakan beberapa inti CPU dalam aplikasi Anda, gunakan multiproses modul sebagai gantinya.

Pertanyaan Umum Demo Slot