Tutorial Global Interpreter Lock Python

Jika Anda baru mulai belajar Python dan ingin mempelajari lebih lanjut, ikuti kursus DataCamp Introduction to Data Science in Python.

Global interpreter lock (GIL) adalah mekanisme untuk menerapkan penguncian global pada sebuah interpreter. Mekanisme ini digunakan di interpreter bahasa pemrograman untuk menyinkronkan dan mengelola eksekusi thread sehingga hanya satu thread native (yang dijadwalkan oleh sistem operasi) yang dapat dieksekusi pada satu waktu.

Dalam skenario saat Anda memiliki banyak thread, yang dapat terjadi adalah kedua thread mungkin mencoba mengakses memori pada saat yang sama, sehingga mereka akan menimpa data di memori. Karena itu, muncul kebutuhan akan mekanisme yang dapat membantu mencegah fenomena ini.

Beberapa interpreter populer yang memiliki GIL adalah CPython dan Ruby MRI. Seperti yang mungkin Anda ketahui, Python adalah bahasa yang diinterpretasikan dan memiliki berbagai distribusi seperti CPython, Jython, IronPython. Di antara ini, GIL hanya didukung di CPython, dan ini juga merupakan implementasi Python yang paling banyak digunakan. CPython dikembangkan dalam bahasa C dan Python terutama untuk mendukung dan bekerja dengan aplikasi yang memiliki banyak komponen bahasa C di balik layar.

Bahkan jika prosesor Anda memiliki banyak inti, global interpreter hanya akan mengizinkan satu thread dieksekusi pada satu waktu. Ini karena, saat sebuah thread mulai berjalan, ia memperoleh global interpreter lock. Ketika menunggu operasi I/O (membaca/menulis data dari/ke disk) atau operasi yang membebani CPU (perkalian vektor/matriks), ia melepaskan lock sehingga thread lain dari proses tersebut dapat berjalan. Dengan demikian, ini mencegah Anda menjalankan thread lain pada saat yang sama.

Mari luangkan waktu untuk memahami diagram di atas. Seperti yang Anda lihat, ada fungsi factorial dan dua thread 1 dan 2, thread 1 berada dalam status terkunci sementara thread 2 dalam status menunggu. Ini berarti hanya salah satu thread yang dapat mengakses fungsi tersebut. Sekarang, anggaplah fungsi factorial membutuhkan 2 detik untuk selesai. Maka, dalam kasus ideal, kedua thread seharusnya dapat menyelesaikan eksekusi dalam 2 detik. Namun, ini tidak terjadi di Python; kedua thread akan berjalan secara seri dan tidak paralel satu sama lain.

Thread 1 dan 2 yang memanggil fungsi factorial dapat memakan waktu dua kali lebih lama dibandingkan satu thread yang memanggil fungsi tersebut dua kali. Ini juga memberi tahu Anda bahwa pengelola memori yang diatur oleh interpreter tidak thread-safe, yang berarti banyak thread gagal mengakses data bersama yang sama secara bersamaan.

Oleh karena itu, GIL (Sumber: Understanding the Python GIL):

• Membatasi operasi threading.

• Eksekusi paralel dibatasi.

• GIL memastikan hanya satu thread yang berjalan di interpreter pada satu waktu.

• Membantu menyederhanakan berbagai detail tingkat rendah seperti manajemen memori.

Dengan GIL, komputasi kooperatif atau multitasking terkoordinasi yang dicapai, bukan komputasi paralel.

Seperti yang dapat diamati dari diagram di atas, ada tiga thread; awalnya thread 1 berjalan dan telah memperoleh GIL, dan ketika operasi I/O seperti baca, tulis, dll. selesai, thread 1 melepaskan GIL dan kemudian diperoleh oleh thread 2. Siklus ini terus berlanjut, dan GIL terus berganti thread secara bergantian hingga thread-thread tersebut menyelesaikan eksekusi program. Ingat bahwa jika ada thread yang tidak memiliki lock dan belum menyelesaikan eksekusi, maka mereka akan berada dalam status menunggu.

GIL di Python2 vs. Python3

Global Interpreter Lock di Python 2.7 bekerja berbeda dibandingkan dengan Python3. Dalam operasi yang murni membebani CPU, thread terus berjalan karena tidak ada operasi I/O; dalam hal ini thread lain akan dalam keadaan idle atau menunggu, yang bukan hal yang Anda inginkan. Untuk mengatasi masalah ini, Python2 memiliki terminologi yang dikenal sebagai ticks. Global interpreter lock melakukan pemeriksaan untuk memantau status thread seperti status menunggu, operasi I/O, atau apakah sedang berjalan. Namun, GIL tidak terus-menerus memantau thread setiap saat; alih-alih, ia menggunakan konsep ticks, dan memeriksa thread setiap 100 tick.

Satu tick adalah instruksi byte-code, dan ketika 100 instruksi byte-code selesai, GIL memeriksa apakah thread sedang berjalan atau dalam status menunggu. Penting untuk diingat bahwa tick tidak terkait waktu karena merupakan instruksi byte-code. Setiap tick mungkin membutuhkan waktu lebih lama atau lebih singkat untuk berjalan dibandingkan yang lain.

Pemeriksaan berkala untuk memantau thread setiap 100 tick ini penting, terutama dalam operasi yang membebani CPU karena tidak memiliki operasi I/O. Perhatikan bahwa Anda dapat mengubah penghitung tick menggunakan modul bawaan Python sys.

Mari bahas beberapa kekurangan dari pendekatan di atas:

Sekarang, jika Anda melihat diagram ini, Anda mungkin memperhatikan bahwa thread tidak berjalan paralel satu sama lain melainkan secara seri, yang juga dikenal sebagai komputasi kooperatif yang diatur oleh global interpreter lock. Selain itu, thread harus menunggu dalam durasi yang lebih lama. Misalnya, thread T3 harus menunggu kedua thread T1 & T2 melepaskan GIL. Maka, thread kekurangan lock dan kemampuan komputasi.

Kekurangan lainnya adalah adanya perebutan di antara thread tentang thread mana yang akan memperoleh GIL. Awalnya, mungkin berdasarkan prioritas T1 mendapatkan GIL, lalu T2, dan seterusnya. Namun, ketika T3 melepaskan GIL, ia akan mengirim pemberitahuan ke semua thread lain, sehingga semua thread lain akan terus berebut untuk memperoleh GIL. Meski begitu, Anda bisa mengatasinya dengan menetapkan prioritas untuk setiap thread.

Di Python3, waktu tetap dialokasikan untuk setiap thread, yaitu 5 ms waktu eksekusi. Ini mencegah thread kekurangan sumber daya karena waktu tunggu sama untuk semua thread. Thread akan menunggu untuk melihat apakah GIL dilepas oleh Thread 1 secara sengaja karena operasi I/O atau sleep. Jika tidak, thread lain akan memaksa pelepasan setelah 5 ms. Maka, tidak akan ada kelaparan waktu CPU karena setiap thread akan mendapatkan jatah waktu yang sama, dan ini akan menghilangkan tantangan dalam memperoleh GIL.

Namun, penting untuk dicatat bahwa implementasi GIL yang baru memberi prioritas lebih tinggi pada pekerjaan yang membebani CPU dibandingkan operasi I/O. Dalam kasus ketika sebuah thread telah melepaskan GIL, dan ada dua thread yang menunggu, GIL akan diperoleh oleh thread yang membutuhkan untuk menjalankan pekerjaan yang membebani CPU dibandingkan thread lainnya.

Kesimpulan

Selamat telah menyelesaikan tutorial ini.

Tutorial ini membahas topik tingkat lanjut, dan tujuannya adalah memberi Anda gambaran teoretis tentang bagaimana GIL bekerja di Python. Karena tutorial ini tidak membahas aspek pengodean GIL dan thread, satu latihan yang baik bagi Anda semua adalah bereksperimen sendiri dengan membuat beberapa thread dan sebuah metode yang melakukan tugas intensif I/O dan akhirnya menganalisis bagaimana GIL berpindah antar thread.

Jangan ragu untuk mengajukan pertanyaan terkait tutorial ini di kolom komentar di bawah.

Referensi:

• Understanding the Python GIL

Jika Anda baru mulai belajar Python dan ingin mempelajari lebih lanjut, ikuti kursus DataCamp Introduction to Data Science in Python.