| page.title=Proses dan Thread |
| page.tags=daur hidup,latar belakang |
| |
| @jd:body |
| |
| <div id="qv-wrapper"> |
| <div id="qv"> |
| |
| <h2>Dalam dokumen ini</h2> |
| <ol> |
| <li><a href="#Processes">Proses</a> |
| <ol> |
| <li><a href="#Lifecycle">Daur hidup proses</a></li> |
| </ol> |
| </li> |
| <li><a href="#Threads">Thread</a> |
| <ol> |
| <li><a href="#WorkerThreads">Thread pekerja</a></li> |
| <li><a href="#ThreadSafe">Metode thread-safe</a></li> |
| </ol> |
| </li> |
| <li><a href="#IPC">Komunikasi antarproses</a></li> |
| </ol> |
| |
| </div> |
| </div> |
| |
| <p>Bila 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.</p> |
| |
| <p>Dokumen ini membahas cara kerja proses dan thread di aplikasi Android.</p> |
| |
| |
| <h2 id="Processes">Proses</h2> |
| |
| <p>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.</p> |
| |
| <p>Entri manifes untuk setiap tipe elemen komponen—<a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code |
| <activity>}</a>, <a href="{@docRoot}guide/topics/manifest/service-element.html">{@code |
| <service>}</a>, <a href="{@docRoot}guide/topics/manifest/receiver-element.html">{@code |
| <receiver>}</a>, dan <a href="{@docRoot}guide/topics/manifest/provider-element.html">{@code |
| <provider>}</a>—mendukung atribut {@code 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 mengatur |
| {@code android:process} agar komponen aplikasi yang berbeda berjalan dalam proses yang sama |
| —sepanjang aplikasi menggunakan ID Linux yang sama dan ditandatangani |
| dengan sertifikat yang sama.</p> |
| |
| <p>Elemen <a href="{@docRoot}guide/topics/manifest/application-element.html">{@code |
| <application>}</a> juga mendukung atribut {@code android:process}, untuk mengatur |
| nilai default yang berlaku bagi semua komponen.</p> |
| |
| <p>Android bisa memutuskan untuk mematikan proses pada waktu tertentu, bila memori tinggal sedikit dan diperlukan oleh |
| proses lain yang lebih mendesak untuk melayani pengguna. Komponen |
| aplikasi yang berjalan dalam proses yang dimatikan maka sebagai konsekuensinya juga akan dimusnahkan. Proses dimulai |
| kembali untuk komponen itu bila ada lagi pekerjaan untuk mereka lakukan.</p> |
| |
| <p>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 keadaan komponen yang berjalan dalam proses tersebut. Aturan |
| yang digunakan untuk menentukan proses yang akan dihentikan dibahas di bawah ini. </p> |
| |
| |
| <h3 id="Lifecycle">Daur hidup proses</h3> |
| |
| <p>Sistem Android mencoba mempertahankan proses aplikasi selama mungkin, namun |
| pada akhirnya perlu menghapus proses lama untuk mengambil kembali memori bagi proses baru atau yang lebih penting. Untuk |
| menentukan proses yang akan |
| dipertahankan dan yang harus dimatikan, sistem menempatkan setiap proses ke dalam "hierarki prioritas" berdasarkan |
| komponen yang berjalan dalam proses dan status komponen tersebut. Proses yang memiliki |
| prioritas terendah akan dimatikan terlebih dahulu, kemudian yang terendah berikutnya, dan seterusnya, jika perlu |
| untuk memulihkan sumber daya sistem.</p> |
| |
| <p>Ada lima tingkatan dalam hierarki prioritas. Daftar berikut berisi beberapa |
| tipe proses berdasarkan urutan prioritas (proses pertama adalah yang <em>terpenting</em> dan |
| <em>dimatikan terakhir</em>):</p> |
| |
| <ol> |
| <li><b>Proses latar depan</b> |
| <p>Proses yang diperlukan untuk aktivitas yang sedang dilakukan pengguna. Proses |
| dianggap berada di latar depan jika salah satu kondisi berikut terpenuhi:</p> |
| |
| <ul> |
| <li>Proses menjadi host {@link android.app.Activity} yang berinteraksi dengan pengguna dengan metode ({@link |
| android.app.Activity}{@link android.app.Activity#onResume onResume()} telah |
| dipanggil).</li> |
| |
| <li>Proses menjadi host {@link android.app.Service} yang terikat dengan aktivitas yang sedang berinteraksi dengan |
| pengguna.</li> |
| |
| <li>Proses menjadi host {@link android.app.Service} yang berjalan "di latar depan"— |
| layanan telah memanggil{@link android.app.Service#startForeground startForeground()}. |
| |
| <li>Proses menjadi host {@link android.app.Service} yang menjalankan salah satu callback |
| daur hidupnya ({@link android.app.Service#onCreate onCreate()}, {@link android.app.Service#onStart |
| onStart()}, atau {@link android.app.Service#onDestroy onDestroy()}).</li> |
| |
| <li>Proses menjadi host {@link android.content.BroadcastReceiver} yang menjalankan metode {@link |
| android.content.BroadcastReceiver#onReceive onReceive()}-nya.</li> |
| </ul> |
| |
| <p>Secara umum, hanya ada beberapa proses latar depan pada waktu yang diberikan. Proses dimatikan hanya sebagai |
| upaya terakhir— jika memori hampir habis sehingga semuanya tidak bisa terus berjalan. Pada umumnya, pada |
| titik itu, perangkat dalam keadaan memory paging, sehingga menghentikan beberapa proses latar depan |
| diperlukan agar antarmuka pengguna tetap responsif.</p></li> |
| |
| <li><b>Proses yang terlihat</b> |
| <p>Proses yang tidak memiliki komponen latar depan, namun masih bisa |
| memengaruhi apa yang dilihat pengguna di layar. Proses dianggap terlihat jika salah satu kondisi |
| berikut terpenuhi:</p> |
| |
| <ul> |
| <li>Proses ini menjadi host {@link android.app.Activity} yang tidak berada di latar depan, namun masih |
| terlihat oleh penggunanya (metode {@link android.app.Activity#onPause onPause()} telah dipanggil). |
| Ini bisa terjadi, misalnya, jika aktivitas latar depan memulai dialog, sehingga |
| aktivitas sebelumnya terlihat berada di belakangnya.</li> |
| |
| <li>Proses menjadi host {@link android.app.Service} yang terikat dengan aktivitas yang terlihat (atau latar |
| depan)</li> |
| </ul> |
| |
| <p>Proses yang terlihat dianggap sangat penting dan tidak akan dimatikan kecuali jika hal itu |
| diperlukan agar semua proses latar depan tetap berjalan. </p> |
| </li> |
| |
| <li><b>Proses layanan</b> |
| <p>Proses yang menjalankan layanan yang telah dimulai dengan metode {@link |
| android.content.Context#startService startService()} dan tidak termasuk dalam salah satu dari dua kategori |
| yang lebih tinggi. Walaupun proses pelayanan tidak langsung terkait dengan semua yang dilihat oleh pengguna, proses ini |
| umumnya melakukan hal-hal yang dipedulikan pengguna (seperti memutar musik di latar belakang |
| atau mengunduh data di jaringan), jadi sistem membuat proses tetap berjalan kecuali memori tidak cukup untuk |
| mempertahankannya bersama semua proses latar depan dan proses yang terlihat. </p> |
| </li> |
| |
| <li><b>Proses latar belakang</b> |
| <p>Proses yang menampung aktivitas yang saat ini tidak terlihat oleh pengguna (metode |
| {@link android.app.Activity#onStop onStop()} aktivitas telah dipanggil). Proses ini tidak memiliki dampak |
| langsung pada pengalaman pengguna, dan sistem bisa menghentikannya kapan saja untuk memperoleh kembali memori bagi |
| proses latar depan, proses yang terlihat, |
| atau proses layanan. Biasanya ada banyak proses latar belakang yang berjalan, sehingga disimpan |
| dalam daftar LRU (least recently used atau paling sedikit digunakan) untuk memastikan bahwa proses dengan aktivitas yang paling baru |
| terlihat oleh pengguna sebagai yang terakhir untuk dimatikan. Jika aktivitas mengimplementasikan metode |
| daur hidupnya dengan benar, dan menyimpan statusnya saat ini, menghentikan prosesnya tidak akan memiliki efek |
| yang terlihat pada pengalaman pengguna, karena ketika pengguna kembali ke aktivitas, aktivitas itu memulihkan |
| semua statusnya yang terlihat. Lihat dokumen <a href="{@docRoot}guide/components/activities.html#SavingActivityState">Aktivitas</a> |
| untuk mendapatkan informasi tentang menyimpan dan memulihkan status.</p> |
| </li> |
| |
| <li><b>Proses kosong</b> |
| <p>Sebuah proses yang tidak berisi komponen aplikasi aktif apa pun. Alasan satu-satunya mempertahankan proses |
| seperti ini tetap hidup adalah untuk keperluan caching, meningkatkan waktu mulai (startup) bila |
| nanti komponen perlu dijalankan di dalamnya. Sistem sering menghentikan proses ini untuk menyeimbangkan sumber |
| daya sistem secara keseluruhan antara proses cache dan cache kernel yang mendasarinya.</p> |
| </li> |
| </ol> |
| |
| |
| <p>Android sebisa mungkin memeringkat proses setinggi |
| mungkin, berdasarkan prioritas komponen yang sedang aktif dalam proses. Misalnya, jika suatu proses menjadi host sebuah layanan dan |
| aktivitas yang terlihat, proses akan diperingkat sebagai proses yang terlihat, bukan sebagai proses layanan.</p> |
| |
| <p>Selain itu, peringkat proses dapat meningkat karena adanya proses lain yang bergantung padanya |
| —proses yang melayani proses lain tidak bisa diperingkat lebih rendah daripada proses yang |
| sedang dilayaninya. Misalnya, jika penyedia konten dalam proses A melayani klien dalam proses B, atau |
| jika layanan dalam proses A terikat dengan komponen dalam proses B, proses A selalu dipertimbangkan sebagai paling rendah |
| prioritasnya dibandingkan dengan proses B.</p> |
| |
| <p>Karena proses yang menjalankan layanan diperingkat lebih tinggi daripada aktivitas latar belakang, |
| aktivitas yang memulai operasi yang berjalan lama mungkin lebih baik memulai <a href="{@docRoot}guide/components/services.html">layanan</a> untuk operasi itu, daripada hanya |
| membuat thread pekerja—khususnya jika operasi mungkin akan berlangsung lebih lama daripada aktivitas. |
| Misalnya, aktivitas yang mengunggah gambar ke situs web harus memulai layanan |
| untuk mengunggah sehingga unggahan bisa terus berjalan di latar belakang meskipun pengguna meninggalkan aktivitas tersebut. |
| Menggunakan layanan akan memastikan operasi paling tidak memiliki prioritas "proses layanan", |
| apa pun yang terjadi pada aktivitas. Ini menjadi alasan yang sama yang membuat penerima siaran harus |
| menjalankan layanan daripada hanya menempatkan operasi yang menghabiskan waktu di thread.</p> |
| |
| |
| |
| |
| <h2 id="Threads">Thread</h2> |
| |
| <p>Bila 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 kejadian menggambar. Ini juga merupakan thread yang |
| membuat aplikasi berinteraksi dengan komponen dari Android UI toolkit (komponen dari paket {@link |
| android.widget} dan {@link android.view}). Karena itu, thread 'main' juga terkadang |
| disebut thread UI.</p> |
| |
| <p>Sistem ini <em>tidak</em> 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 {@link android.view.View#onKeyDown onKeyDown()} untuk melaporkan tindakan pengguna atau metode callback daur hidup) |
| selalu berjalan di thread UI proses.</p> |
| |
| <p>Misalnya saat pengguna menyentuh tombol pada layar, thread UI aplikasi akan mengirim kejadian |
| sentuh ke widget, yang selanjutnya menetapkan status ditekan dan mengirim permintaan yang tidak divalidasi ke |
| antrean kejadian. Thread UI akan menghapus antrean permintaan dan memberi tahu widget bahwa widget harus menggambar |
| dirinya sendiri.</p> |
| |
| <p>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 query |
| database akan memblokir seluruh UI. Bila thread diblokir, tidak ada kejadian yang bisa dikirim, |
| termasuk kejadian menggambar. Dari sudut pandang pengguna, aplikasi |
| tampak mogok (hang). Lebih buruk lagi, jika thread UI diblokir selama lebih dari beberapa detik |
| (saat ini sekitar 5 detik) pengguna akan ditampilkan dialog "<a href="http://developer.android.com/guide/practices/responsiveness.html">aplikasi tidak |
| merespons</a>" (ANR) yang populer karena reputasi buruknya. Pengguna nanti bisa memutuskan untuk keluar dari aplikasi dan menghapus aplikasi |
| jika mereka tidak suka.</p> |
| |
| <p>Selain itu, toolkit Android UI <em>bukan</em> 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:</p> |
| |
| <ol> |
| <li>Jangan memblokir thread UI |
| <li>Jangan mengakses toolkit Android UI dari luar thread UI |
| </ol> |
| |
| <h3 id="WorkerThreads">Thread pekerja</h3> |
| |
| <p>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").</p> |
| |
| <p>Misalnya, berikut ini beberapa kode untuk listener klik yang mengunduh gambar dari |
| thread terpisah dan menampilkannya dalam {@link android.widget.ImageView}:</p> |
| |
| <pre> |
| public void onClick(View v) { |
| new Thread(new Runnable() { |
| public void run() { |
| Bitmap b = loadImageFromNetwork("http://example.com/image.png"); |
| mImageView.setImageBitmap(b); |
| } |
| }).start(); |
| } |
| </pre> |
| |
| <p>Awalnya hal ini tampak bekerja dengan baik, karena menciptakan thread baru untuk menangani |
| operasi jaringan. Akan tetapi, hal tersebut melanggar aturan kedua model thread tunggal: <em>jangan mengakses |
| toolkit Android UI dari luar thread UI</em>—sampel ini memodifikasi {@link |
| android.widget.ImageView} dari thread pekerja sebagai ganti thread UI. Ini bisa |
| mengakibatkan perilaku yang tidak terdefinisi dan tidak diharapkan, yang bisa menyulitkan dan menghabiskan waktu untuk melacaknya.</p> |
| |
| <p>Untuk memperbaiki masalah ini, Android menawarkan beberapa cara untuk mengakses thread UI dari |
| thread lainnya. Berikut ini daftar metode yang bisa membantu:</p> |
| |
| <ul> |
| <li>{@link android.app.Activity#runOnUiThread(java.lang.Runnable) |
| Activity.runOnUiThread(Runnable)}</li> |
| <li>{@link android.view.View#post(java.lang.Runnable) View.post(Runnable)}</li> |
| <li>{@link android.view.View#postDelayed(java.lang.Runnable, long) View.postDelayed(Runnable, |
| long)}</li> |
| </ul> |
| |
| <p>Misalnya, Anda bisa memperbaiki kode di atas dengan menggunakan metode {@link |
| android.view.View#post(java.lang.Runnable) View.post(Runnable)}:</p> |
| |
| <pre> |
| public void onClick(View v) { |
| new Thread(new Runnable() { |
| public void run() { |
| final Bitmap bitmap = loadImageFromNetwork("http://example.com/image.png"); |
| mImageView.post(new Runnable() { |
| public void run() { |
| mImageView.setImageBitmap(bitmap); |
| } |
| }); |
| } |
| }).start(); |
| } |
| </pre> |
| |
| <p>Kini implementasi ini thread-safe: operasi jaringan dilakukan terpisah dari thread |
| sementara {@link android.widget.ImageView} dimanipulasi dari thread UI.</p> |
| |
| <p>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 {@link android.os.Handler}di thread pekerja, untuk memproses pesan yang dikirim dari |
| thread UI. Mungkin solusi terbaiknya adalah memperpanjang kelas {@link android.os.AsyncTask}, |
| yang akan menyederhanakan eksekusi tugas-tugas thread pekerja yang perlu berinteraksi dengan UI.</p> |
| |
| |
| <h4 id="AsyncTask">Menggunakan AsyncTask</h4> |
| |
| <p>Dengan {@link android.os.AsyncTask}, Anda bisa melakukan pekerjaan asinkron pada antarmuka |
| pengguna. AsyncTask memblokir operasi di thread pekerja kemudian mempublikasikan hasilnya |
| di thread UI, tanpa mengharuskan Anda untuk menangani sendiri thread dan/atau handler sendiri.</p> |
| |
| <p>Untuk menggunakannya, Anda harus menempatkan {@link android.os.AsyncTask} sebagai subkelas dan mengimplementasikan metode callback {@link |
| android.os.AsyncTask#doInBackground doInBackground()} yang berjalan di kumpulan |
| thread latar belakang. Untuk memperbarui UI, Anda harus mengimplementasikan {@link |
| android.os.AsyncTask#onPostExecute onPostExecute()}, yang memberikan hasil dari {@link |
| android.os.AsyncTask#doInBackground doInBackground()} dan berjalan di thread UI, jadi Anda bisa |
| memperbarui UI dengan aman. Selanjutnya Anda bisa menjalankan tugas dengan memanggil {@link android.os.AsyncTask#execute execute()} |
| dari thread UI.</p> |
| |
| <p>Misalnya, Anda bisa mengimplementasikan contoh sebelumnya menggunakan {@link android.os.AsyncTask} dengan cara |
| ini:</p> |
| |
| <pre> |
| public void onClick(View v) { |
| new DownloadImageTask().execute("http://example.com/image.png"); |
| } |
| |
| private class DownloadImageTask extends AsyncTask<String, Void, Bitmap> { |
| /** The system calls this to perform work in a worker thread and |
| * delivers it the parameters given to AsyncTask.execute() */ |
| protected Bitmap doInBackground(String... urls) { |
| return loadImageFromNetwork(urls[0]); |
| } |
| |
| /** The system calls this to perform work in the UI thread and delivers |
| * the result from doInBackground() */ |
| protected void onPostExecute(Bitmap result) { |
| mImageView.setImageBitmap(result); |
| } |
| } |
| </pre> |
| |
| <p>Kini UI aman dan kode jadi lebih sederhana, karena memisahkan pekerjaan ke |
| dalam bagian-bagian yang harus dilakukan pada thread pekerja dan thread UI.</p> |
| |
| <p>Anda harus membaca acuan {@link android.os.AsyncTask} untuk memahami sepenuhnya |
| cara menggunakan kelas ini, namun berikut ini ikhtisar singkat cara kerjanya:</p> |
| |
| <ul> |
| <li>Anda bisa menetapkan tipe parameter, nilai kemajuan, dan nilai |
| akhir tugas, dengan menggunakan generik</li> |
| <li>Metode {@link android.os.AsyncTask#doInBackground doInBackground()} berjalan secara otomatis pada |
| thread pekerja</li> |
| <li>{@link android.os.AsyncTask#onPreExecute onPreExecute()}, {@link |
| android.os.AsyncTask#onPostExecute onPostExecute()}, dan {@link |
| android.os.AsyncTask#onProgressUpdate onProgressUpdate()} semuanya dipanggil pada thread UI</li> |
| <li>Nilai yang dikembalikan oleh {@link android.os.AsyncTask#doInBackground doInBackground()} akan dikirim ke |
| {@link android.os.AsyncTask#onPostExecute onPostExecute()}</li> |
| <li>Anda bisa memangil {@link android.os.AsyncTask#publishProgress publishProgress()} setiap saat di {@link |
| android.os.AsyncTask#doInBackground doInBackground()} untuk mengeksekusi {@link |
| android.os.AsyncTask#onProgressUpdate onProgressUpdate()} pada thread UI</li> |
| <li>Anda bisa membatalkan tugas ini kapan saja, dari thread mana saja</li> |
| </ul> |
| |
| <p class="caution"><strong>Perhatian:</strong> Masalah lain yang mungkin Anda temui saat menggunakan |
| thread pekerja adalah restart tak terduga dalam aktivitas karena <a href="{@docRoot}guide/topics/resources/runtime-changes.html">perubahan konfigurasi runtime</a> |
| (seperti saat pengguna mengubah orientasi layar), yang bisa memusnahkan thread pekerja. Untuk |
| melihat cara mempertahankan tugas selama restart ini dan cara membatalkan |
| tugas dengan benar saat aktivitas dimusnahkan, lihat kode sumber untuk aplikasi sampel <a href="http://code.google.com/p/shelves/">Shelves</a>.</p> |
| |
| |
| <h3 id="ThreadSafe">Metode thread-safe</h3> |
| |
| <p> Dalam beberapa situasi, metode yang Anda implementasikan bisa dipanggil dari lebih dari satu thread, |
| dan karena itu harus ditulis agar menjadi thread-safe. </p> |
| |
| <p>Ini terutama terjadi untuk metode yang bisa dipanggil dari jauh —seperti metode dalam <a href="{@docRoot}guide/components/bound-services.html">layanan terikat</a>. Bila sebuah panggilan pada |
| metode yang dijalankan dalam {@link android.os.IBinder} berasal dari proses yang sama di mana |
| {@link android.os.IBinder IBinder} berjalan, metode ini akan dieksekusi di thread pemanggil. |
| Akan tetapi, bila panggilan berasal proses lain, metode akan dieksekusi dalam thread yang dipilih dari |
| kumpulan (pool) thread yang dipertahankan sistem dalam proses yang sama seperti{@link android.os.IBinder |
| IBinder} (tidak dieksekusi dalam thread UI proses). Misalnya, karena metode |
| {@link android.app.Service#onBind onBind()} layanan akan dipanggil dari thread UI |
| proses layanan, metode yang diimplementasikan dalam objek yang dikembalikan {@link android.app.Service#onBind |
| onBind()} (misalnya, subkelas yang mengimplementasikan metode RPC) akan dipanggil dari thread |
| di pool. Karena layanan bisa memiliki lebih dari satu klien, maka lebih dari satu pool thread bisa melibatkan |
| metode {@link android.os.IBinder IBinder} yang sama sekaligus. Metode {@link android.os.IBinder |
| IBinder} karenanya harus diimplementasikan sebagai thread-safe.</p> |
| |
| <p> Penyedia konten juga bisa menerima permintaan data yang berasal dalam proses lain. |
| Meskipun kelas {@link android.content.ContentResolver} dan {@link android.content.ContentProvider} |
| menyembunyikan detail cara komunikasi antarproses dikelola, metode {@link |
| android.content.ContentProvider} yang merespons permintaan itu—metode {@link |
| android.content.ContentProvider#query query()}, {@link android.content.ContentProvider#insert |
| insert()}, {@link android.content.ContentProvider#delete delete()}, {@link |
| android.content.ContentProvider#update update()}, dan {@link android.content.ContentProvider#getType |
| getType()}— dipanggil dari pool thread pada proses penyedia konten, 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. </p> |
| |
| |
| <h2 id="IPC">Komunikasi Antarproses</h2> |
| |
| <p>Android menawarkan mekanisme komunikasi antarproses (IPC) menggunakan panggilan prosedur jauh |
| (RPC), yang mana metode ini dipanggil oleh aktivitas atau komponen aplikasi lain, namun 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 RPC. </p> |
| |
| <p>Untuk melakukan IPC, aplikasi Anda harus diikat ke layanan, dengan menggunakan {@link |
| android.content.Context#bindService bindService()}. Untuk informasi selengkapnya, lihat panduan pengembang <a href="{@docRoot}guide/components/services.html">Layanan</a>.</p> |
| |
| |
| <!-- |
| <h2>Beginner's Path</h2> |
| |
| <p>For information about how to perform work in the background for an indefinite period of time |
| (without a user interface), continue with the <b><a |
| href="{@docRoot}guide/components/services.html">Services</a></b> document.</p> |
| --> |