Multithreading dengan Python dengan Contoh:Belajar GIL dengan Python

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

Selain itu, seorang filsuf harus mengambil dua garpu yang berdekatan dengannya (yaitu, garpu kiri dan kanan) sebelum dia bisa makan spageti. Masalah kebuntuan terjadi ketika kelima filsuf mengambil garpu kanan mereka secara bersamaan.

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

Demikian pula, dalam sistem konkuren, kebuntuan terjadi ketika utas atau proses (filsuf) yang berbeda mencoba untuk memperoleh sumber daya sistem bersama (garpu) pada saat yang sama. Akibatnya, tidak ada proses yang mendapat kesempatan untuk dieksekusi karena menunggu resource lain yang dipegang oleh proses lain.

Kondisi Balapan

Kondisi balapan adalah keadaan program yang tidak diinginkan yang terjadi ketika sistem melakukan dua atau lebih operasi secara bersamaan. Misalnya, pertimbangkan loop for sederhana ini:

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

Jika Anda membuat n jumlah utas yang menjalankan kode ini sekaligus, Anda tidak dapat menentukan nilai i (yang dibagi oleh utas) ketika program selesai dieksekusi. Ini karena dalam lingkungan multithreading nyata, utas dapat tumpang tindih, dan nilai i yang diambil dan dimodifikasi oleh utas dapat berubah di antara saat beberapa utas lain mengaksesnya.

Ini adalah dua kelas utama masalah yang dapat terjadi dalam aplikasi python multithreaded atau terdistribusi. Di bagian berikutnya, Anda akan mempelajari cara mengatasi masalah ini dengan menyinkronkan utas.

Menyinkronkan rangkaian pesan

Untuk menangani kondisi balapan, kebuntuan, dan masalah berbasis thread lainnya, modul threading menyediakan Kunci obyek. Idenya adalah ketika sebuah utas menginginkan akses ke sumber daya tertentu, ia memperoleh kunci untuk sumber daya itu. Setelah utas mengunci sumber daya tertentu, tidak ada utas lain yang dapat mengaksesnya hingga kunci dilepaskan. Akibatnya, perubahan pada sumber daya akan bersifat atomik, dan kondisi balapan akan dihindari.

Kunci adalah primitif sinkronisasi tingkat rendah yang diterapkan oleh __thread modul. Pada waktu tertentu, kunci dapat berada di salah satu dari 2 status:terkunci atau tidak terkunci. Ini mendukung dua metode:

1. memperoleh() Saat status kunci tidak terkunci, memanggil metode acquire() akan mengubah status menjadi terkunci dan kembali. Namun, jika status terkunci, panggilan ke acquire() diblokir hingga metode release() dipanggil oleh beberapa thread lain.
2. rilis() Metode release() digunakan untuk mengatur status menjadi tidak terkunci, yaitu, untuk melepaskan kunci. Itu dapat dipanggil oleh utas apa pun, tidak harus yang memperoleh kunci.

Berikut ini contoh penggunaan kunci di aplikasi Anda. Jalankan IDLE Anda dan ketik 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 output seperti ini:

KODE PENJELASAN

1. Di sini, Anda cukup membuat kunci baru dengan memanggil threading.Lock() fungsi pabrik. Secara internal, Lock() mengembalikan instance kelas Lock beton paling efektif yang dikelola oleh platform.
2. Dalam pernyataan pertama, Anda memperoleh kunci dengan memanggil metode acquire(). Ketika kunci telah diberikan, Anda mencetak “kunci diperoleh” ke konsol. Setelah semua kode yang Anda inginkan untuk menjalankan utas selesai dieksekusi, Anda melepaskan kunci dengan memanggil metode release().

Teorinya baik-baik saja, tetapi bagaimana Anda tahu bahwa kunci itu benar-benar berfungsi? Jika Anda melihat hasilnya, Anda akan melihat bahwa setiap pernyataan cetak mencetak tepat satu baris pada satu waktu. Ingatlah bahwa, dalam contoh sebelumnya, output dari print di mana serampangan karena beberapa utas mengakses metode print() secara bersamaan. Di sini, fungsi cetak dipanggil hanya setelah kunci diperoleh. Jadi, output ditampilkan satu per satu dan baris demi baris.

Selain kunci, python juga mendukung beberapa mekanisme lain untuk menangani sinkronisasi utas seperti yang tercantum di bawah ini:

1. Kunci kembali
2. Semafor
3. Kondisi
4. Acara, dan
5. Hambatan

Kunci Juru Bahasa Global (dan cara mengatasinya)

Sebelum masuk ke detail GIL python, mari kita definisikan beberapa istilah yang akan berguna untuk memahami bagian yang akan datang:

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

Apa itu GIL di Python?

Kunci Penerjemah Global (GIL) di python adalah kunci proses atau mutex yang digunakan saat berurusan dengan proses. Itu memastikan bahwa satu utas dapat mengakses sumber daya tertentu pada satu waktu dan juga mencegah penggunaan objek dan bytecode sekaligus. Ini menguntungkan program single-threaded dalam peningkatan kinerja. GIL di python sangat sederhana dan mudah diimplementasikan.

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

Salah satu fitur Python adalah menggunakan kunci global pada setiap proses interpreter, yang berarti bahwa setiap proses memperlakukan interpreter python itu sendiri sebagai sumber daya.

Misalnya, Anda telah menulis program python yang menggunakan dua utas untuk melakukan operasi CPU dan 'I/O'. Saat Anda menjalankan program ini, inilah yang terjadi:

1. Penerjemah python membuat proses baru dan memunculkan utas
2. Saat thread-1 mulai berjalan, pertama-tama ia akan memperoleh GIL dan menguncinya.
3. Jika thread-2 ingin dijalankan sekarang, ia harus menunggu GIL dirilis meskipun prosesor lain gratis.
4. Sekarang, misalkan thread-1 sedang menunggu operasi I/O. Saat ini, GIL akan dirilis, dan thread-2 akan mendapatkannya.
5. Setelah menyelesaikan operasi I/O, jika thread-1 ingin dieksekusi sekarang, maka harus menunggu lagi GIL dirilis oleh thread-2.

Karena itu, hanya satu utas yang dapat mengakses penerjemah setiap saat, artinya hanya akan ada satu utas yang mengeksekusi kode python pada titik waktu tertentu.

Ini baik-baik saja dalam prosesor single-core karena akan menggunakan time slicing (lihat bagian pertama dari tutorial ini) untuk menangani utas. Namun, dalam kasus prosesor multi-inti, fungsi terikat-CPU yang dijalankan pada banyak utas akan memiliki dampak yang cukup besar pada efisiensi program karena tidak akan benar-benar menggunakan semua inti yang tersedia secara bersamaan.

Mengapa GIL dibutuhkan?

Pengumpul sampah CPython menggunakan teknik manajemen memori yang efisien yang dikenal sebagai penghitungan referensi. Begini cara kerjanya:Setiap objek di python memiliki jumlah referensi, yang meningkat ketika ditugaskan ke nama variabel baru atau ditambahkan ke wadah (seperti tupel, daftar, dll.). Demikian juga, jumlah referensi berkurang ketika referensi keluar dari ruang lingkup atau ketika pernyataan del dipanggil. Ketika jumlah referensi suatu objek mencapai 0, itu adalah sampah yang dikumpulkan, dan memori yang dialokasikan dibebaskan.

Tetapi masalahnya adalah bahwa variabel jumlah referensi rentan terhadap kondisi balapan seperti variabel global lainnya. Untuk mengatasi masalah ini, pengembang python memutuskan untuk menggunakan kunci penerjemah global. Opsi lainnya adalah menambahkan kunci ke setiap objek yang akan mengakibatkan kebuntuan dan peningkatan overhead dari panggilan acquire() dan release().

Oleh karena itu, GIL adalah batasan signifikan untuk program python multithreaded yang menjalankan operasi terikat CPU yang berat (secara efektif menjadikannya single-threaded). Jika Anda ingin menggunakan beberapa inti CPU dalam aplikasi Anda, gunakan multiprosesing modul sebagai gantinya.

Ringkasan

• Python mendukung 2 modul untuk multithreading:
  1. __utas module:Ini menyediakan implementasi tingkat rendah untuk threading dan sudah usang.
  2. modul threading :Ini memberikan implementasi tingkat tinggi untuk multithreading dan merupakan standar saat ini.
• Untuk membuat thread menggunakan modul threading, Anda harus melakukan hal berikut:
  1. Buat kelas yang memperluas Utas kelas.
  2. Ganti konstruktornya (__init__).
  3. Ganti run() its metode.
  4. Buat objek kelas ini.
• Sebuah thread dapat dieksekusi dengan memanggil start() metode.
• Yang gabung() metode ini dapat digunakan untuk memblokir utas lain hingga utas ini (utas tempat bergabung dipanggil) menyelesaikan eksekusi.
• Kondisi balapan terjadi saat beberapa utas mengakses atau memodifikasi sumber daya bersama secara bersamaan.
• Ini dapat dihindari dengan Menyinkronkan utas.
• Python mendukung 6 cara untuk menyinkronkan utas:
  1. Kunci
  2. Kunci kembali
  3. Semafor
  4. Kondisi
  5. Acara, dan
  6. Hambatan
• Kunci hanya mengizinkan utas tertentu yang telah memperoleh kunci untuk memasuki bagian kritis.
• Kunci memiliki 2 metode utama:
  1. memperoleh() :Ini menetapkan status kunci ke terkunci. Jika dipanggil pada objek yang terkunci, objek tersebut akan memblokir hingga sumber dayanya kosong.
  2. rilis() :Ini menyetel status kunci ke tidak terkunci dan kembali. Jika dipanggil pada objek yang tidak terkunci, ia mengembalikan false.
• Kunci penerjemah global adalah mekanisme yang hanya dapat dijalankan oleh 1 proses penerjemah CPython dalam satu waktu.
• Ini digunakan untuk memfasilitasi fungsi penghitungan referensi pengumpul sampah CPythons.
• Untuk membuat aplikasi Python dengan operasi berat terikat CPU, Anda harus menggunakan modul multiprosesor.