Thread, atau kadang-kadang disebut proses ringan (lightweight), adalah unit dasar dari utilisasi CPU. Di dalamnya terdapat ID thread, program counter, register, dan stack. Dan saling berbagi dengan thread lain dalam proses yang sama.
Gambar 2-16. Thread
1. Konsep Dasar
Secara informal, proses adalah program yang sedang dieksekusi. Ada dua jenis proses, proses berat (heavyweight) atau biasa dikenal dengan proses tradisional, dan proses ringan atau kadang disebut thread. Thread saling berbagi bagian program, bagian data dan sumber daya sistem operasi dengan thread lain yang mengacu pada proses yang sama. Thread terdiri atas ID thread, program counter, himpunan register, dan stack. Dengan banyak kontrol thread proses dapat melakukan lebih dari satu pekerjaan pada waktu yang sama.
2. Keuntungan
- Tanggap: Multithreading mengizinkan program untuk berjalan terus walau pun pada bagian program tersebut di block atau sedang dalam keadaan menjalankan operasi yang lama/ panjang. Sebagai contoh, multithread web browser dapat mengizinkan pengguna berinteraksi dengan suatu thread ketika suatu gambar sedang diload oleh thread yang lain.
- Pembagian sumber daya: Secara default, thread membagi memori dan sumber daya dari proses. Keuntungan dari pembagian kode adalah aplikasi mempunyai perbedaan aktifitas thread dengan alokasi memori yang sama.
- Ekonomis: Mengalokasikan memori dan sumber daya untuk membuat proses adalah sangat mahal. Alternatifnya, karena thread membagi sumber daya dari proses, ini lebih ekonomis untuk membuat threads.
- Pemberdayaan arsitektur multiprosesor: Keuntungann dari multithreading dapat ditingkatkan dengan arsitektur multiprosesor, dimana setiap thread dapat jalan secara parallel pada prosesor yang berbeda. Pada arsitektur prosesor tunggal, CPU biasanya berpindah-pindah antara setiap thread dengan cepat, sehingga terdapat ilusi paralelisme, tetapi pada kenyataannya hanya satu thread yang berjalan di setiap waktu.
3. User Threads
Gambar 2-17. User dan Kernel Thread
User thread didukung oleh kernel dan diimplementasikan oleh thread library ditingkat pengguna. Library mendukung untuk pembentukan thread, penjadualan, dan managemen yang tidak didukung oleh kernel.
4. Kernel Threads
Kernel thread didukung secara langsung oleh sistem operasi: pembentukan thread, penjadualan, dan managemen dilakukan oleh kernel dalam ruang kernel. Karena managemen thread telah dilakukan oleh sistem operasi, kernel thread biasanya lebih lambat untuk membuat dan mengelola daripada pengguna thread. Bagaimana pun, selama kernel mengelola thread, jika suatu thread di block tehadap sistem pemanggilan, kernel dapat menjadualkan thread yang lain dalam aplikasi untuk dieksekusi. Juga, di dalam lingkungan multiprosesor, kernel dapat menjadualkan thread dalam prosesor yang berbeda. Windows NT, Solaris, dan Digital UNIX adalah sistem operasi yang mendukung kernel thread.
5. Model Multithreading
Dalam sub bab sebelumnya telah dibahas pengertian dari thread, keuntungannya, tingkatan atau levelnya seperti pengguna dan kernel. Maka dalam sub-bab ini pembahasan akan dilanjutkan dengan jenis-jenis thread tersebut dan contohnya baik pada Solaris mau pun Java.
Sistem-sistem yang ada sekarang sudah banyak yang bisa mendukung untuk kedua pengguna dan kernel thread, sehingga model-model multithreading-nya pun menjadi beragam. Implementasi multithreading yang umum akan kita bahas ada tiga, yaitu model many-to-one, one-to-one, dan many-to-many.
Gambar 2-18. Model Multithreading
6. Model Many to One
Model many-to-one ini memetakan beberapa tingkatan pengguna thread hanya ke satu buah kernel thread. Managemen proses thread dilakukan oleh (di ruang) pengguna, sehingga menjadi efisien, tetapi apabila sebuah thread melakukan sebuah pemblokingan terhadap sistem pemanggilan, maka seluruh proses akan berhenti (blocked). Kelemahan dari model ini adalah multihreads tidak dapat berjalan atau bekerja secara paralel di dalam multiprosesor dikarenakan hanya satu thread saja yang bisa mengakses kernel dalam suatu waktu.
Gambar 2-19. Model Many to One
7. Model One to One
Model one-to-one memetakan setiap thread pengguna ke dalam satu kernel thread. Hal ini membuat model one-to-one lebih sinkron daripada model many-to-one dengan mengizinkan thread lain untuk berjalan ketika suatu thread membuat pemblokingan terhadap sistem pemanggilan; hal ini juga mengizinkan multiple thread untuk berjalan secara parallel dalam multiprosesor. Kelemahan model ini adalah dalam pembuatan thread pengguna dibutuhkan pembuatan korespondensi thread pengguna. Karena dalam proses pembuatan kernel thread dapat mempengaruhi kinerja dari aplikasi maka kebanyakan dari implementasi model ini membatasi jumlah thread yang didukung oleh sistem. Model one-to-one diimplementasikan oleh Windows NT dan OS/2.
Gambar 2-20. Model One to One
8. Model Many to Many
Beberapa tingkatan thread pengguna dapat menggunakan jumlah kernel thread yang lebih kecil atau sama dengan jumlah thread pengguna. Jumlah dari kernel thread dapat dispesifikasikan untuk beberapa aplikasi dan beberapa mesin (suatu aplikasi dapat dialokasikan lebih dari beberapa kernel thread dalam multiprosesor daripada dalam uniprosesor) dimana model many-to-one mengizinkan pengembang untuk membuat thread pengguna sebanyak mungkin, konkurensi tidak dapat tercapai karena hanya satu thread yang dapat dijadualkan oleh kernel dalam satu waktu. Model one-to-one mempunyai konkurensi yang lebih tinggi, tetapi pengembang harus hati-hati untuk tidak membuat terlalu banyak thread tanpa aplikasi dan dalam kasus tertentu mungkin jumlah thread yang dapat dibuat dibatasi.
Gambar 2-21. Model Many to Many
9. Thread Dalam Solaris 2
Solaris 2 merupakan salah satu versi dari UNIX yang sampai dengan tahun 1992 hanya masih mendukung proses berat (heavyweight) dengan kontrol oleh satu buah thread. Tetapi sekarang Solaris 2 sudah berubah menjadi sistem operasi yang modern yang mendukung threads di dalam level kernel dan pengguna, multiprosesor simetrik (SMP), dan penjadualan real-time.
Threads di dalam Solaris 2 sudah dilengkapi dengan library mengenai API-API untuk pembuatan dan managemen thread. Di dalam Solaris 2 terdapat juga level tengah thread. Di antara level pengguna dan level kernel thread terdapat proses ringan/ lightweight (LWP). Setiap proses yang ada setidaknya mengandung minimal satu buah LWP. Library thread memasangkan beberapa thread level pengguna ke ruang LWP-LWP untuk diproses, dan hanya satu user-level thread yang sedang terpasang ke suatu LWP yang bisa berjalan. Sisanya bisa diblok mau pun menunggu untuk LWP yang bisa dijalankan.
Operasi-operasi di kernel seluruhnya dieksekusi oleh kernel-level threads yang standar. Terdapat satu kernel-level thread untuk tiap LWP, tetapi ada juga beberapa kernel-level threads yang berjalan di bagian kernel tanpa diasosiasikan dengan suatu LWP (misalnya thread untuk pengalokasian disk). Thread kernel-level merupakan satu-satunya objek yang dijadualkan ke dalam sistem (lihat Bagian 2.7 mengenai scheduling). Solaris menggunakan model many-to-many.
Thread level pengguna dalam Solaris bisa berjenis bound mau pun unbound. Suatu bound thread level pengguna secara permanen terpasang ke suatu LWP. Jadi hanya thread tersebut yang bekerja di LWP, dan dengan suatu permintaan, LWP tersebut bisa diteruskan ke suatu prosesor. Dalam beberapa situasi yang membutuhkan waktu respon yang cepat (seperti aplikasi real-time), mengikat suatu thread sangatlah berguna. Suatu thread yang unbound tidak secara permanen terpasang ke suatu LWP. Semua threads unbound dipasangkan (secara multiplex) ke dalam suatu ruang yang berisi LWP-LWP yang tersedia untuk aplikasi. Secara default thread-thread yang ada adalah unbound.
Misalnya sistem sedang beroperasi, setiap proses bisa mempunyai threads level pengguna yang banyak. User-user level thread ini bisa dijadual dan diganti di antara LWP-LWP-nya oleh thread library tanpa intervensi dari kernel. User-level threads sangatlah efisien karena tidak dibutuhkan bantuan kerja kernel oleh thread library untuk menukar dari satu user-level thread ke yang lain.
Setiap LWP terpasang dengan tepat satu kernel-level thread, dimana setiap user-level thread tidak tergantung dari kernel. Suatu proses mungkin mempunyai banyak LWP, tetapi mereka hanya dibutuhkan ketika thread harus berkomunikasi dengan kernel. Misalnya, suatu LWP akan dibutuhkan untuk setiap thread yang bloknya konkuren di sistem pemanggilan. Anggap ada lima buah pembacaan berkas yang muncul. Jadi dibutuhkan lima LWP, karena semuanya mungkin mengunggu untuk penyelesaian proses I/O di kernel. Jika suatu proses hanya mempunyai empat LWP, maka permintaan yang kelima harus menunggu unuk salah satu LWP kembali dari kernel. Menambah LWP yang keenam akan sia-sia jika hanya terdapat tempat untuk lima proses.
Kernel-kernel threads dijadual oleh penjadual kernel dan dieksekusi di CPU atau CPU-CPU dalam sistemnya. Jika suatu kernel thread memblok (misalnya karena menunggu penyelesaian suatu proses I/O), prosesor akan bebas untuk menjalankan kernel thread yang lain. Jika thread yang sedang terblok sedang menjalankan suatu bagian dari LWP, maka LWP tersebut akan ikut terblok. Di tingkat yang lebih atas lagi, user-level thread yang sedang terpasang ke LWP tersebut akan terblok juga. Jika suatu proses mempunyai lebih dari satu LWP, maka LWP lain bisa dijadual oleh kernel.
Para pengembang menggunakan struktur-struktur data sebagai berikut untuk mengimplementasikan thread-thread dalam Solaris 2:
- Suatu user-level thread mempunyai thread ID, himpunan register (mencakup suatu PC dan stack pointer), stack dan prioritas (digunakan oleh library untuk penjadualan). Semua struktur data tersebut berasal dari ruang user.
- Suatu LWP mempunyai suatu himpunan register untuk user-level thread yang ia jalankan, juga memori dan informasi pencatatan. LWP merupakan suatu struktur data dari kernel, dan bertempat pada ruang kernel.
- Suatu kernel thread hanya mempunyai struktur data yang kecil dan sebuah stack. Struktur datanya melingkupi copy dari kernel-kernel registers, suatu pointer yang menunjuk ke LWP yang terpasang dengannya, dan informasi tentang prioritas dan penjadualan.
Setiap proses dalam Solaris 2 mempunyai banyak informasi yang terdapat di process control block (PCB). Secara umum, suatu proses di Solaris mempunyai suatu proses id (PID), peta memori, daftar dari berkas yang terbuka, prioritas, dan pointer yang menunjuk ke daftar LWP yang terasosiasi kedalam proses.
Gambar 2-22. Thread Solaris dan Java
10. Thread Java
Seperti yang telah kita lihat, thread didukung selain oleh sistem operasi juga oleh paket library thread. Sebagai contoh, Win32 library mempunyai API untuk multithreading aplikasi Windows, dan Pthreads mempunyai fungsi manajmen thread untuk sistem POSIX-compliant. Java adalah unik dalam mendukung tingkatan bahasa untuk membuat dan managemen thread.
Semua program java mempunyai paling sedikit satu kontrol thread. Bahkan program java yang sederhana mempunyai hanya satu main() method yang berjalan dalam thread tunggal dalam JVM. Java menyediakan perintah-perintah yang mendukung pengembang untuk membuat dan memanipulasi kontrol thread pada program.
Satu cara untuk membuat thread secara eksplisit adalah dengan membuat kelas baru yang diturunkan dari kelas thread, dan menimpa run() method dari kelas Thread tersebut.
Object yang diturunkan dari kelas tersebut akan menjalankan sebagian thread control dalam JVM. Bagaimana pun, membuat suatu objek yang diturunkan dari kelas Thread tidak secara spesifik membuat thread baru, tetapi start() method lah yang sebenarnya membuat thread baru.
Memanggil start() method untuk objek baru mengalokasikan memori dan menginisialisasikan thread baru dalam JVM dan memanggil run() method membuat thread pantas untuk dijalankan oleh JVM. (Catatan: jangan pernah memanggil run() method secara langsung. Panggil start() method dan ini secara langsung akan memanggil run() method).
Ketika program ini dijalankan, dua thread akan dibuat oleh JVM. Yang pertama dibuat adalah thread yang berasosiasi dengan aplikasi-thread tersebut mulai dieksekusi pada main() method. Thread kedua adalah runner thread secara ekspilisit dibuat dengan start() method. Runner thread memulai eksekusinya dengan run() method.
Pilihan lain untuk membuat sebuah thread yang terpisah adalah dengan mendefinisikan suatu kelas yang mengimplementasikan runnable interface. Runnable interface tersebut didefinisikan sebagai berikut:
Runnable
Public interface Runnable
{
Public abstract void run();
}
Sehingga, ketika sebuah kelas diimplementasikan dengan runnable, kelas tersebut harus mendefinisikan run() method. Kelas thread yang berfungsi untuk mendefinisikan static dan instance method, juga mengimplementasikan runnable interface. Itu menerangkan bahwa mengapa sebuah kelas diturunkan dari thread harus mendefinisikan run() method.
Implementasi dari runnable interface sama dengan mengekstend kelas thread, satu-satunya kemungkinan untuk mengganti "extends thread" dengan "implements runnable".
Class Worker2
Class worker2 implements Runnable
{
Public void run() {
System. Out. Println ("I am a worker thread. "); }
}
Membuat sebuah thread dari kelas yang diimplementasikan oleh runnable berbeda dengan membuat thread dari kelas yang mengekstend thread. Selama kelas baru tersebut tidak mengekstend thread, dia tidak mempunyai akses ke objek static atau instance method --- seperti start() method --- dari kelas thread. Bagaimana pun, sebuah objek dari kelas thread adalah tetap dibutuhkan, karena yang membuat sebuah thread baru dari kontrol adalah start() method.
Di kelas kedua, sebuah objek thread baru dibuat melalui runnable objek dalam konstruktornya. Ketika thread dibuat oleh start() method, thread baru mulai dieksekusi pada run() method dari runnable objek. Kedua method dari pembuatan thread tersebut adalah cara yang paling sering digunakan.
11. Managemen Thread
Java menyediakan beberapa fasilitas API untuk mengatur thread --- thread, diantaranya adalah:
- Suspend(): berfungsi untuk menunda eksekusi dari thread yang sedang berjalan.
- Sleep(): berfungsi untuk menempatkan thread yang sedang berjalan untuk tidur dalam beberapa waktu.
- Resume(): hasil eksekusi dari thread yang sedang ditunda.
- Stop(): menghentikan eksekusi dari sebuah thread; sekali thread telah dihentikan dia tidak akan memulainya lagi.
Setiap method yang berbeda untuk mengontrol keadaan dari thread mungkin akan berguna dalam situasi tertentu. Sebagai contoh: Applets adalah contoh alami untuk multithreading karena mereka biasanya memiliki grafik, animasi, dan audio --- semuanya sangat baik untuk mengatur berbagai thread yang terpisah. Bagaimana pun, itu tidak akan mungkin bagi sebuah applet untuk berjalan ketika dia sedang tidak ditampilkan, jika applet sedang menjalankan CPU secara intensif. Sebuah cara untuk menangani situasi ini adalah dengan menjalankan applet sebagai thread terpisah dari kontrol, menunda thread ketika applet sedang tidak ditampilkan dan melaporkannya ketika applet ditampilkan kembali.
Anda dapat melakukannya dengan mencatat bahwa start() method dari sebuah applet dipanggil ketika applet tersebut pertama kali ditampilkan. Apabila user meninggalkan halaman web atau applet keluar dari tampilan, maka method stop() pada applet dipanggil (ini merupakan suatu keuntungan karena start() dan stop() keduanya terasosiasi dengan thread dan applet). Jika user kembali ke halaman web applet, kemudian start() method dipanggil kembali. Destroy() method dari sebuah applet dipanggil ketika applet tersebut dipindahkan dari cache-nya browser. Ini memungkinkan untuk mencegah sebuah applet berjalan ketika applet tersebut sedang tidak ditampilkan pada sebuah web browser dengan menggunakan stop() method dari applet yang ditunda dan melaporkan eksekusi tersebut pada thread di applet start() method.
12. Keadaan Thread
Sebuah thread java dapat menjadi satu dari 4 kemungkinan keadaan:
- new: sebuah thread pada keadaan ini ada ketika objek dari thread tersebut dibuat.
- runnable: memanggil start() method untuk mengalokasikan memori bagi thread baru dalam JVM dan memanggil run() method untuk membuat objek.
- block: sebuah thread akan diblok jika menampilkan sebuah kalimat pengeblokan. Contohnya: sleep() atau suspend().
- dead: sebuah thread dipindahkan ke keadaan dead ketika run() method berhenti atau ketika stop() method dipanggil.
Gambar 2-25. Keadaan Thread
13. Thread dan JVM
Pada penambahannya ke java program mengandung beberapa thread yang berbeda dari kontrol, disini ada beberapa thead yang sedang berjalan secara tidak sinkron untuk kepentingan dari penanganan sistem tingkatan JVM seperti managemen memori dan grafik kontrol. Garbage Collector mengevaluasi objek ketika JVM untuk dilihat ketika mereka sedang digunakan. Jika tidak, maka itu akan kembali ke memori dalam sistem.
14. JVM dan Sistem Operasi
Secara tipikal implementasi dari JVM adalah pada bagian atas terdapat host sistem operasi, pengaturan ini mengizinkan JVM untuk menyembunyikan detail implementasi dari sistem operasi dan menyediakan sebuah kekonsistenan, lingkungan yang abstrak tersebut mengizinkan program-program java untuk beroprasi pada berbagai sistem operasi yang mendukung sebuah JVM. Spesifikasi bagi JVM tidak mengidentifikasi bagaimana java thread dipetakan ke dalam sistem operasi.
15. Contoh Solusi Multithreaded
Pada bagian ini, kita memperkenalkan sebuah solusi multithreaded secara lengkap kepada masalah produser konsumer yang menggunakan penyampaian pesan. Kelas server pertama kali membuat sebuah mailbox untuk mengumpulkan pesan, dengan menggunakan kelas message queue kemudian dibuat produser dan konsumer threads secara terpisah dan setiap thread mereferensi ke dalam mailbox bersama. Thread produser secara bergantian antara tidur untuk sementara, memproduksi item, dan memasukkan item ke dalam mailbox. Konsumer bergantian antara tidur dan mengambil suatu item dari mailbox dan mengkonsumsinya. Karena receive() method dari kelas message queue adalah tanpa pengeblokan, konsumer harus mencek apakah pesan yang diambilnya tersebut adalah nol.
Pustaka
Buku ini dipersembahkan dari Gabungan Kelompok Kerja 21--28 IKI-20230 Semester Genap 2002/ 2003, oleh Gabungan Kelompok Kerja 21--28 IKI-20230 Semester Genap 2002/ 2003, untuk siapa saja yang ingin mempelajari Sistem Operasi. Tim penyusun buku ini ialah sebagai berikut:
Kelompok 21 (Koordinator)
Dhani Yuliarso, Fernan, Hanny Faristin, Melanie Tedja, Paramanandana D.M., Widya Yuwanda.
Kelompok 22 (Bab 1)
Budiono Wibowo, Agus Setiawan, Baya U.H.S., Budi A. Azis Dede Junaedi, Heriyanto, Muhammad Rusdi.
Kelompok 23 (Bab 2)
Indra Agung, Ali Khumaidi, Arifullah, Baihaki A.S., Christian K.F. Daeli, Eries Nugroho, Eko Seno P., Habrar, Haris Sahlan.
Kelompok 24 (Bab 3)
Adzan Wahyu Jatmiko, Agung Pratomo, Dedy Kurniawan, Samiaji Adisasmito, Zidni Agni.
Kelompok 25 (Bab 4)
Nasrullah, Amy S. Indrasari, Ihsan Wahyu, Inge Evita Putri, Muhammad Faizal Ardhi, Muhammad Zaki Rahman, N. Rifka N. Liputo, Nelly, Nur Indah, R. Ayu P., Sita A.R.
Kelompok 26 (Bab 5)
Rakhmad Azhari, Adhe Aries, Adityo Pratomo, Aldiantoro Nugroho, Framadhan A., Pelangi, Satrio Baskoro Y.
Kelompok 27 (Bab 6)
Teuku Amir F.K., Alex Hendra Nilam, Anggraini W., Ardini Ridhatillah, R. Ferdy Ferdian, Ripta Ramelan, Suluh Legowo, Zulkifli.
Kelompok 28 (Bab 7)
Sistem Operasi: Bahan Kuliah IKI-20230 oleh Gabungan Kelompok Kerja 21--28 IKI-20230 Semester Genap 2002/2003
$Revision: 1.3.0.0 $ Edisi
Diterbitkan 30 September 2003
Copyright (Hak Cipta) © 2003 oleh Gabungan Kelompok Kerja 21--28 IKI-20230 Semester Genap 2002/ 2003.
Silakan menyalin, mengedarkan, dan/ atau, memodifikasi bagian dari dokumen -- $Revision: 1.3.0.0 $ -- -- yang dikarang oleh Gabungan Kelompok Kerja 21--28 IKI-20230 Semester Genap 2002/ 2003, sesuai dengan ketentuan "GNU Free Documentation License versi 1.1" atau versi selanjutnya dari FSF (Free Software Foundation); tanpa bagian "Invariant", tanpa teks "Front-Cover", dan tanpa teks "Back-Cover". Lampiran A ini berisi salinan lengkap dari lisensi tersebut. Ketentuan ini TIDAK berlaku untuk bagian dan/ atau kutipan yang bukan dikarang oleh Gabungan Kelompok Kerja 21--28 IKI-20230 Semester Genap 2002/ 2003.
Catatan Revisi
Revisi 1.3 30-09-2003 Revised by: RMS46
Revisi ini diedit oleh Rahmat M. Samik-Ibrahim: melanjutkan perbaikan tata letak dan pengindeksan.
Revisi 1.2 17-09-2003 Revised by: RMS46
Revisi ini diedit oleh Rahmat M. Samik-Ibrahim: melanjutkan perbaikan.
Revisi 1.1 01-09-2003 Revised by: RMS46
Revisi ini diedit oleh Rahmat M. Samik-Ibrahim: melakukan perbaikan struktur SGML, tanpa terlalu banyak mengubah isi buku.
Revisi 1.0 27-05-2003 Revised by: RMS46
Kompilasi ulang, serta melakukan sedikit perapihan.
Revisi 0.21.4 05-05-2003 Revised by: Kelompok 21 Perapihan berkas dan penambahan entity.
Revisi 0.21.3 29-04-2003 Revised by: Kelompok 21 Perubahan dengan menyempurnakan nama file.
Revisi 0.21.2 24-04-2003 Revised by: Kelompok 21
Merubah Kata Pengantar.
Revisi 0.21.1 21-04-2003 Revised by: Kelompok 21
Menambahkan Daftar Pustaka dan Index.
Revisi 0.21.0 26-03-2003 Revised by: Kelompok 21 Memulai membuat tugas kelompok kuliah Sistem Operasi.
Christiono H, Arief Purnama L.K., Arman Rahmanto, Fajar, Muhammad Ichsan, Rama P. Tardan, Unedo Sanro Simon.
