Thread yang sudah siap untuk dieksekusi namun masih dalam daftar tunggu berada dalam state ..... *

THREAD

KELOMPOK E AKBAR ALI SHOHIBUL CHAERUL SUTAMI GAGAN GALIH MARGAN YOHANES

CONTENT THREAD MULTITHREADING MODEL MULTITHREADING SYMETRIC MULTITPROCESSING ASYMETRIC MULTITPROCESSING PROSES & THREAD KOMPONEN & JENIS THREAD STATE PADA THREAD PEMBUATAN & PENGHENTIAN THREAD KEUNTUNGAN & KERUGIAN THREAD STUDI KASUS

THREAD Thread (menurut beberapa sumber) adalah : Merupakan sebuah status eksekusi (running, ready, dll) Merupakan sebuah pengontrol aliran program Sering disebut dengan lightweight process (proses ringan) Merupakan unit dasar dari penggunaan CPU yang terdiri dari Thread_ID, program counter, register set, dan stack Ada pula yang menyebutkan bahwa thread adalah sebuah mini proses dari sebuah proses

THREAD Secara informal, proses adalah program yang sedang dieksekusi. Ada 2 jenis proses, proses berat (heavyweight) & proses ringan atau kadang disebut thread. Thread saling berbagi bagian program, bagian data & sumber daya SO dengan thread lain yang mengacu pada proses yang sama. Dengan banyak kontrol, thread dapat melakukan lebih dari satu pekerjaan pada waktu yang sama

THREAD Single-threading Multi-threading sebuah proses tradisional (heavyweight) mempunyai thread tunggal yang berfungsi sebagai pengendali Multi-threading sebuah proses dengan thread yang banyak & mengerjakan lebih dari satu tugas pada satu satuan waktu

MULTITHREADING Many-to-One Memetakan beberapa thread tingkatan pengguna kesebuah thread tingkatan kernel Pengaturan thread dilakukan dalam ruang pengguna, sehingga efisien Hanya satu thread pengguna yang dapat mengakses thread kernel pada satu saat.

MULTITHREADING One-to-One Memetakan setiap thread tingkatan pengguna ke thread kernel Model ini menyediakan lebih banyak concurrency dibandingkan model Many-to-One

MULTITHREADING Many-to-Many Mengelompokkan banyak thread pengguna untuk dipetakan ke thread kernel yang jumlahnya lebih sedikit atau sama dengan tingkatan pengguna Mengijinkan sistem operasi untuk membuat sejumlah thread kernel

SYMMETRIC MULTITPROCESSING Merupakan tipe arsitektur komputer dimana dua atau lebih processor berbagi link pada memory yang sama Keunggulan utama sistem SMP ini adalah bahwa sistem SMP mengoptimalkan kerja semua processornya dalam tingkatan yang sama, sehingga memberikan kualitas akses yang sama pada hardware komputer yang lain Banyak software saat ini terbagi ke dalam bagian-bagian yang lebih kecil yang disebut dengan thread. Ketika program-program ini berjalan pada sistem SMP, setiap processor dapat menjalankan satu thread program, sehingga dapat meningkatkan performa keseluruhan

ASYMMETRIC MULTITPROCESSING Setiap processor diberikan suatu tugas yang spesifik. Processor master mengontrol sistem, processor lain menunggu instruksi master atau mempunyai tugas yang ditentukan oleh master. Skema ini merupakan hubungan master-slave. Prosessor master menjadwal dan mengalokasikan pekerjaan dari processor slave.

PERBEDAAN PROSES DAN THREAD Thread berbeda dengan proses karena thread memiliki address space yang sama yang artinya mereka berbagi variable global. Karenanya masing-masing thread dapat saling mengakses virtual address, membaca, menulis bahkan menghentikan thread lain. Sedangkan proses bisa dimiliki oleh user dan kemungkinan proses tersebut menunggu atau ditahan proses yang lain. proses selalu dimiliki oleh satu user sehingga mereka dapat saling bekerja sama tidak saling berbenturan.

PERBEDAAN PROSES DAN THREAD

JENIS-JENIS THREAD User Thread (Thread Pengguna) Thread pengguna didukung kernel serta diimplementasikan dengan pustaka (library) thread pada tingkatan pengguna Pustaka (library) menyediakan fasilitas untuk pembuatan thread, penjadwalan thread, dan manajemen thread tanpa dukungan dari kernel Semua pembuatan dan penjadwalan thread dilakukan dalam ruang pengguna tanpa campur tangan kernel. Thread pengguna biasanya dapat cepat dibuat dan dikendalikan

JENIS-JENIS THREAD Kernel Threads (Thread Kernel) Thread kernel didukung langsung oleh sistem operasi Pembuatan, penjadwalan, dan manajemen thread dilakukan oleh kernel pada kernel space Pengaturan thread dilakukan oleh sistem operasi, sehingga pembuatan dan pengaturan kernel thread lebih lambat dibandingkan user thread

STATE PADA THREAD Sebuah thread memungkinkan untuk memiliki beberapa state : Running Sebuah thread yang pada saat ini sedang dieksekusi dan didalam control dari CPU Ready to run Thread yang sudah siap untuk dieksekusi, tetapi masih belum ada kesempatan untuk melakukannya Resumed Setelah sebelumnya di block atau diberhenti kan sementara, state ini kemudian siap untuk dijalankan Suspended Sebuah thread yang berhenti sementara, dan kemudian memperbolehkan CPU untuk menjalankan thread lain bekerja Blocked Sebuah thread yang diblock merupakan sebuah thread yang tidak mampu berjalan, karena ia akan menunggu sebuah resource tersedia atau sebuah event terjadi

THREAD POOL Pembuatan thread yang tidak terbatas jumlahnya dapat menurunkan performa dari sistem. Solusinya adalah dengan penggunaan Thread Pools, cara kerjanya adalah dengan membuat beberapa thread pada proses startup dan menempatkan mereka ke pools, dimana thread tersebut menunggu untuk bekerja. Jadi ketika server menerima permintaan maka akan membangunkan thread dari pool dan jika thread tersebut tersedia, permintaan akan dilayani. Ketika thread sudah selesai mengerjakan tugasnya maka thread tersebut kembali ke pool dan menunggu pekerjaan lainnya. Bila tidak thread yang tersedia pada saat dibutuhkan, maka server menunggu sampai ada satu thread yang bebas.

PUSTAKA THREAD Pustaka Thread atau yang lebih familiar dikenal dengan Thread Library bertugas untuk menyediakan API untuk programmer dalam menciptakan dan memanage thread. Ada dua cara dalam mengimplementasikan pustaka thread: Menyediakan API dalam level pengguna tanpa dukungan dari kernel sehingga pemanggilan fungsi tidak melalui system call. Jadi, jika kita memanggil fungsi yang sudah ada di pustaka, maka akan menghasilkan pemanggilan fungsi call yang sifatnya lokal dan bukan system call. Menyediakan API di level kernel yang didukung secara langsung oleh sistem operasi. Pemanggilan fungsi call akan melibatkan system call ke kernel.

PENGHENTIAN THREAD Thread Cancellation adalah sebuah tugas untuk memberhentikan thread sebelum thread tersebut selesai. Terdapat 2 skenario, yaitu : Asynchronous cancellation Satu thread memberhentikan target thread seketika itu juga Deferred cancellation Target thread secara periodik dapat mengecek apakah ia harus berhenti, skenario ini memberi kesempatan kepada target thread untuk memberhentikan dirinya sendiri

KEUNTUNGAN THREAD Responsif Multithreading memungkinkan suatu program running walaupun sebagian program di-block atau menjalankan operasi yang lain. Contoh: web browser Resource Sharing Thread dapat men-share memori dan resource dengan thread yang lain Ekonomis Alokasi memori dan resource untuk pembuatan proses memiliki cost yang mahal. Dalam hal context-switch, lebih ekonomis bila dilakukan dengan thread context-switch Utilisasi CPU Meningkatkan kinerja pada arsitektur multiprocessor, dimana thread running secara paralel pada processor yang berbeda

KERUGIAN THREAD Jika digunakan secara berlebihan, multithreading akan berdampak pada pemborosan resource dan CPU yang dialokasikan untuk switching threads. Sistem yang memiliki kecepatan prosesor dan memory yang cenderung sama, sehingga tidak ada efisiensi yang hilang (mengacu kepada latency), tidak akan memperoleh peningkatan bandwidth yang signifikan jika menggunakan multithreading Multithreading menghasilkan program yang lebih kompleks. Menggunakan multiple thread sendiri tidak akan menciptakan kerumitan, tapi interaksi antar thread-lah yang mengakibatkan kompleksitas tersebut. Thread yang banyak bisa saling berinterferensi ketika saling berbagi sumber daya hardware seperti cache.

IMPLEMENTASI (STUDI KASUS) Terkadang ada sebuah aplikasi yang perlu menjalankan beberapa tugas yang serupa. Sebagai contohnya sebuah web server dapat mempunyai ratusan klien yang mengaksesnya secara bersamaan. Jika web server berjalan sebagai proses yang memiliki thread tunggal (Single-Threading) maka ia hanya dapat melayani satu klien pada satu waktu. Bila ada klien lain yang ingin mengajukan permintaan maka ia harus menunggu sampai klien sebelumnya selesai dilayani. Solusinya adalah dengan membuat web server menjadi Multi-Threading. Dengan ini maka sebuah web server akan membuat thread yang akan mendengar permintaan klien, ketika permintaan lain diajukan maka web server akan menciptakan thread lain yang akan melayani permintaan tersebut.

GRACIAS AMIGOS!

Jika komponen aplikasi dimulai dan tidak ada komponen aplikasi lain yang berjalan, sistem Android akan memulai proses Linux baru untuk aplikasi dengan satu thread eksekusi. Secara default, semua komponen aplikasi yang sama berjalan dalam proses dan thread yang sama (disebut thread "utama"). Jika komponen aplikasi dimulai dan sudah ada proses untuk aplikasi itu (karena komponen lain dari aplikasi itu sudah ada), maka komponen akan dimulai dalam proses itu dan menggunakan thread eksekusi yang sama. Akan tetapi, Anda bisa mengatur komponen berbeda di aplikasi agar berjalan di proses terpisah, dan Anda bisa membuat thread tambahan untuk setiap proses.

Dokumen ini membahas cara kerja proses dan thread di aplikasi Android.

Proses

Secara default, semua komponen aplikasi yang sama berjalan dalam proses yang sama dan kebanyakan aplikasi tidak boleh mengubah ini. Akan tetapi, jika Anda merasa perlu mengontrol proses milik komponen tertentu, Anda dapat melakukannya dalam file manifes.

Entri manifes untuk setiap tipe elemen komponen—, , , dan —mendukung atribut android:process yang bisa menetapkan dalam proses mana komponen harus dijalankan. Anda bisa mengatur atribut ini agar setiap komponen berjalan dalam prosesnya sendiri atau agar beberapa komponen menggunakan proses yang sama sementara yang lainnya tidak. Anda juga bisa menyetel android:process agar komponen aplikasi yang berbeda berjalan dalam proses yang sama—sepanjang aplikasi menggunakan ID pengguna Linux yang sama dan ditandatangani dengan sertifikat yang sama.

Elemen juga mendukung atribut android:process, untuk menyetel nilai default yang berlaku bagi semua komponen.

Android bisa memutuskan untuk mematikan proses pada waktu tertentu, jika memori tinggal sedikit dan diperlukan oleh proses lain yang lebih mendesak untuk melayani pengguna. Komponen aplikasi yang berjalan dalam proses yang dimatikan konsekuensinya juga akan dimusnahkan. Proses dimulai kembali untuk komponen tersebut jika ada lagi pekerjaan untuk mereka lakukan.

Saat memutuskan proses yang akan dimatikan, sistem Android akan mempertimbangkan kepentingan relatifnya bagi pengguna. Misalnya, sistem lebih mudah menghentikan proses yang menjadi host aktivitas yang tidak lagi terlihat di layar, dibandingkan dengan proses yang menjadi host aktivitas yang terlihat. Karena itu, keputusan untuk menghentikan proses bergantung pada status komponen yang berjalan dalam proses tersebut.

Detail daur hidup proses dan hubungannya dengan status aplikasi dibahas dalam Daur Hidup Proses dan Aplikasi.

Thread

Jika aplikasi diluncurkan, sistem akan membuat thread eksekusi untuk aplikasi tersebut, yang diberi nama, "main". Thread ini sangat penting karena bertugas mengirim kejadian ke widget antarmuka pengguna yang sesuai, termasuk peristiwa menggambar. Ini juga hampir selalu merupakan thread yang membuat aplikasi berinteraksi dengan komponen dari toolkit Android UI (komponen dari paket android.widget dan android.view). Karena itu, thread 'main' juga terkadang disebut thread UI. Namun, pada situasi tertentu, thread utama aplikasi mungkin bukan thread UI-nya; untuk informasi selengkapnya, lihat Anotasi Thread.

Sistem ini tidak membuat thread terpisah untuk setiap instance komponen. Semua komponen yang berjalan di proses yang sama akan dibuat instance-nya dalam thread UI, dan sistem akan memanggil setiap komponen yang dikirim dari thread itu. Akibatnya, metode yang merespons callback sistem (seperti onKeyDown() untuk melaporkan tindakan pengguna atau metode callback daur hidup) selalu berjalan di thread UI proses.

Misalnya saat pengguna menyentuh tombol pada layar, thread UI aplikasi akan mengirim peristiwa sentuh ke widget, yang selanjutnya menetapkan status ditekan dan memposting permintaan yang tidak divalidasi ke antrean peristiwa. Thread UI akan menghapus antrean permintaan dan memberi tahu widget bahwa widget harus menggambar ulang dirinya sendiri.

Saat aplikasi melakukan pekerjaan intensif sebagai respons terhadap interaksi pengguna, model thread tunggal ini bisa menghasilkan kinerja yang buruk kecuali jika Anda mengimplementasikan aplikasi dengan benar. Khususnya jika semua terjadi di thread UI, melakukan operasi yang panjang seperti akses ke jaringan atau kueri database akan memblokir seluruh UI. Jika thread diblokir, tidak ada peristiwa yang bisa dikirim, termasuk peristiwa menggambar. Dari sudut pandang pengguna, aplikasi seperti hang atau mogok. Lebih buruk lagi, jika thread UI diblokir selama lebih dari beberapa detik (saat ini sekitar 5 detik) pengguna akan ditampilkan dialog "aplikasi tidak merespons" (ANR) yang populer karena reputasi buruknya. Pengguna nanti bisa memutuskan untuk keluar dari aplikasi dan menghapus aplikasi jika tidak suka.

Selain itu, toolkit Android UI bukan thread-safe. Jadi, Anda tidak harus memanipulasi UI dari thread pekerja—Anda harus melakukan semua manipulasi pada antarmuka pengguna dari thread UI. Sehingga hanya ada dua aturan untuk model thread tunggal Android:

1. Jangan memblokir thread UI
2. Jangan mengakses toolkit Android UI dari luar thread UI

Thread pekerja

Karena model thread tunggal yang dijelaskan di atas, Anda dilarang memblokir thread UI demi daya respons UI aplikasi. Jika memiliki operasi untuk dijalankan yang tidak seketika, Anda harus memastikan untuk melakukannya di thread terpisah (thread "latar belakang" atau thread "pekerja").

Namun, ingat bahwa Anda tidak dapat memperbarui UI dari thread selain dari thread UI atau thread "utama".

Untuk memperbaiki masalah ini, Android menawarkan beberapa cara untuk mengakses thread UI dari thread lainnya. Berikut ini daftar metode yang bisa membantu:

fun onClick(v: View) { Thread(Runnable { // a potentially time consuming task val bitmap = processBitMap("image.png") imageView.post { imageView.setImageBitmap(bitmap) } }).start() }

public void onClick(View v) { new Thread(new Runnable() { public void run() { // a potentially time consuming task final Bitmap bitmap = processBitMap("image.png"); imageView.post(new Runnable() { public void run() { imageView.setImageBitmap(bitmap); } }); } }).start(); }

Kini implementasi ini thread-safe: operasi latar belakang dilakukan dari thread terpisah sementara ImageView selalu dimanipulasi dari thread UI.

Akan tetapi, karena operasi semakin kompleks, jenis kode seperti ini bisa semakin rumit dan sulit dipertahankan. Untuk menangani interaksi yang lebih kompleks dengan thread pekerja, Anda bisa mempertimbangkan penggunaan Handler di thread pekerja, untuk memproses pesan yang dikirim dari thread UI. Mungkin solusi terbaiknya adalah memperpanjang kelas AsyncTask, yang akan menyederhanakan eksekusi tugas-tugas thread pekerja yang perlu berinteraksi dengan UI.

Menggunakan AsyncTask

Dengan AsyncTask, memungkinkan Anda melakukan pekerjaan asinkron pada antarmuka pengguna. Hal ini memblokir operasi di thread pekerja kemudian mempublikasikan hasilnya di thread UI, tanpa mengharuskan Anda untuk menangani sendiri thread dan/atau penangan sendiri.

Untuk menggunakannya, Anda harus menjadikan AsyncTask sebagai subkelas dan mengimplementasikan metode callback doInBackground() yang berjalan di pool thread latar belakang. Untuk memperbarui UI, Anda harus mengimplementasikan onPostExecute(), yang mengirim hasil dari doInBackground() dan berjalan di thread UI, jadi Anda bisa memperbarui UI dengan aman. Kemudian Anda bisa menjalankan tugas dengan memanggil execute() dari thread UI.

Anda harus membaca referensi AsyncTask untuk memahami sepenuhnya cara menggunakan kelas ini.

Metode thread-safe

Dalam beberapa situasi, metode yang Anda implementasikan bisa dipanggil dari lebih dari satu thread, dan karena itu harus ditulis agar menjadi thread-safe.

Ini terutama terjadi untuk metode yang bisa dipanggil dari jauh—seperti metode dalam layanan terikat. Jika sebuah panggilan pada metode yang diimplementasikan pada IBinder berasal dari proses yang sama di mana IBinder berjalan, metode akan dijalankan di thread pemanggil. Namun, jika panggilan berasal proses lain, metode akan dieksekusi dalam thread yang dipilih dari kumpulan (pool) thread yang dipertahankan sistem dalam proses yang sama seperti IBinder (tidak dijalankan dalam thread UI proses). Misalnya, karena metode onBind() layanan akan dipanggil dari thread UI proses layanan, metode yang diimplementasikan dalam objek yang dikembalikan onBind() (misalnya, subclass yang mengimplementasikan metode RPC) akan dipanggil dari thread dalam pool. Karena layanan bisa memiliki lebih dari satu klien, maka lebih dari satu pool thread bisa melibatkan metode IBinder yang sama sekaligus. Metode IBinder karenanya harus diimplementasikan sebagai thread-safe.

Demikian pula, penyedia materi bisa menerima permintaan data yang berasal dari proses lain. Meskipun class ContentResolver dan ContentProvider menyembunyikan detail cara mengelola komunikasi antarproses, metode ContentProvider yang merespons permintaan itu—metode query(), insert(), delete(), update(), dan getType()—dipanggil dari pool thread pada proses penyedia materi, bukan thread UI untuk proses tersebut. Mengingat metode ini bisa dipanggil dari thread mana pun sekaligus, metode-metode ini juga harus diimplementasikan sebagai thread-safe.

Komunikasi antarproses

Android menawarkan mekanisme komunikasi antarproses (IPC) menggunakan panggilan prosedur jauh (PPK), yang mana metode ini dipanggil oleh aktivitas atau komponen aplikasi lain, tetapi dieksekusi dari jauh (di proses lain), bersama hasil yang dikembalikan ke pemanggil. Ini mengharuskan penguraian panggilan metode dan datanya ke tingkat yang bisa dipahami sistem operasi, mentransmisikannya dari proses lokal dan ruang alamat untuk proses jauh dan ruang proses, kemudian merakit kembali dan menetapkannya kembali di sana. Nilai-nilai yang dikembalikan akan ditransmisikan dalam arah berlawanan. Android menyediakan semua kode untuk melakukan transaksi IPC ini, sehingga Anda bisa fokus pada pendefinisian dan implementasi antarmuka pemrograman PPK.

Untuk melakukan IPC, aplikasi Anda harus ditautkan ke layanan, menggunakan bindService(). Untuk informasi selengkapnya, lihat panduan developer Layanan.