Android: Kapan saya harus menggunakan Handler () dan kapan saya harus menggunakan Thread?

Ketika saya membutuhkan sesuatu untuk berjalan secara tidak sinkron , seperti tugas yang berjalan lama atau logika yang menggunakan jaringan, atau untuk alasan apa pun, Memulai Thread baru dan menjalankannya berfungsi dengan baik. Membuat Handler dan menjalankannya juga berfungsi. Apa bedanya? Kapan saya harus menggunakan masing-masing? Apa keuntungan / alasan untuk menggunakan Handlerdan bukan Thread?

PS. - Demi pertanyaan ini, mari kita abaikan AsyncTask. - Handler().postDelayeduse case jelas bagi saya, demi pertanyaan ini mari kita asumsikan saya perlu tugas untuk memulai segera.

Jika apa pun yang Anda lakukan "berat", Anda harus melakukannya di Thread. Jika Anda tidak memulai secara eksplisit di utasnya sendiri, maka ia akan berjalan pada utas utama (UI) yang mungkin terlihat gelisah atau lambat merespons antarmuka oleh pengguna Anda.

Menariknya ketika Anda menggunakan utas, sering juga berguna untuk menggunakan Handler sebagai sarana komunikasi antara utas yang Anda mulai dan utas utama.

Interaksi Thread / Handler yang khas mungkin terlihat seperti ini:

Handler h = new Handler(){
    @Override
    public void handleMessage(Message msg){
        if(msg.what == 0){
            updateUI();
        }else{
            showErrorDialog();
        }
    }
};

Thread t = new Thread() {
    @Override
    public void run(){
        doSomeWork();
        if(succeed){
            //we can't update the UI from here so we'll signal our handler and it will do it for us.
            h.sendEmptyMessage(0);
        }else{
            h.sendEmptyMessage(1);
        }
    }   
};

Secara umum, yang perlu dibawa pulang adalah Anda harus menggunakan Thread setiap kali Anda melakukan beberapa pekerjaan yang bisa berjalan lama atau sangat intensif (mis. Jaringan apa pun, file IO, aritmatik berat, dll).

Handler dan Thread benar-benar 2 hal yang berbeda.

Thread harus dibuat untuk menjalankan pekerjaan yang sudah berjalan lama.

Handler adalah objek yang sangat nyaman untuk berkomunikasi antara 2 utas (misalnya: utas latar perlu memperbarui UI. Anda dapat menggunakan Handler untuk memposting beberapa Runnable dari utas latar Anda ke utas UI).

Jadi Anda tidak punya pilihan antara Handler atau Thread. Gunakan utas untuk melakukan pekerjaan berat! (Anda dapat menggunakan Handler jika utas latar belakang Anda akan memicu beberapa pekerjaan untuk dikerjakan di utas lain - sebagian besar waktu utas UI)

Handlerdan Threadada dua hal yang berbeda, tetapi mereka tidak saling bertentangan. Anda dapat memiliki Handlerdan Threadpada saat yang sama dan sebenarnya masing-masing Handlerharus berjalan dalam Thread.

Untuk lebih jelasnya, Anda mungkin ingin membaca artikel ini .

A Handlerberjalan di sama Thread, a Threadberjalan di utas berbeda.

Gunakan Handler jika Anda perlu menjalankan sesuatu pada utas yang sama , biasanya elemen GUI atau sesuatu seperti itu.

Gunakan Utas jika Anda ingin utas utama bebas melakukan hal-hal lain . Gunakan ini untuk apa pun yang membutuhkan banyak waktu.

Penangan adalah cara komunikasi terbaik antara latar belakang dan utas UI. Umumnya Handler dikaitkan dengan antrian pesan dari Thread dan mereka digunakan untuk mengirim pesan dan dapat dijalankan ke Pesan.

MENGGUNAKAN:

Utas: Untuk melakukan tugas dalam utas (Latar Belakang) ulir dari utas UI. (membantu untuk membuka blokir utas UI)

Handler Digunakan untuk berkomunikasi antara UI dan utas Latar.

Lihat artikel ini

Jika Anda perlu memperbarui antarmuka pengguna dari Utas baru, Anda harus menyinkronkan dengan utas antarmuka pengguna.

Anda dapat menggunakan kelas android.os.Handler atau kelas AsyncTasks untuk ini.

Kelas Handler dapat memperbarui antarmuka pengguna. Handler menyediakan metode untuk menerima instance dari kelas Message atau Runnable.

Anda dapat memposting pesan melalui metode sendMessage (Pesan pesan) atau melalui metode sendEmptyMessage ().

... info lebih lanjut di sini tentang utas dll. (termasuk turorial untuk berbagai threading dan mekanisme sinkronisasi serta kapan harus menggunakan apa)

Apa keuntungan / alasan menggunakan Handler dan bukan Thread?

Sebuah Handler memungkinkan Anda untuk mengirim dan proses Pesan dan Runnablebenda yang berhubungan dengan thread ini MessageQueue. Setiap Handlerinstance dikaitkan dengan utas tunggal dan antrian pesan utas itu.

Saat Anda membuat yang baru Handler, ia terikat ke antrian utas / pesan dari utas yang membuatnya - sejak saat itu, ia akan mengirimkan pesan dan runnables ke antrian pesan itu dan menjalankannya saat keluar dari antrian pesan .

Ada dua kegunaan utama untuk Handler:

1. Untuk menjadwalkan pesan dan Runnables akan dieksekusi sebagai titik di masa depan
2. Untuk enqueue tindakan yang akan dilakukan pada thread yang berbeda dari Anda sendiri.

Jika Anda menggunakan utas java, Anda harus menangani sesuatu sendiri - menyinkronkan dengan utas utama, membatalkan utas dll.

Utas tunggal ini tidak membuat kumpulan utas kecuali Anda menggunakan ThreadPoolExecutoratau ExecutorServiceAPI.

(Ambil permintaan ini dari komentar Anda pada jawaban Blackbelt)

Mengapa tidak menggunakan Pelaksana? dan bahkan jika saya ingin menggunakan Handler untuk melakukan itu, bagaimana?

Referensi: Artikel Kinerja Utas

Ada beberapa jenis pekerjaan yang dapat direduksi menjadi tugas yang sangat paralel dan terdistribusi. Dengan banyaknya paket kerja yang diciptakan, AsyncTaskdan HandlerThreadini bukan kelas yang sesuai. Sifat single-threaded AsyncTaskakan mengubah semua pekerjaan threadpool menjadi sistem linier. Menggunakan HandlerThreadkelas, di sisi lain, akan membutuhkan programmer untuk secara manual mengelola load balancing antara sekelompok thread.

ThreadPoolExecutor adalah kelas pembantu untuk membuat proses ini lebih mudah. Kelas ini mengelola pembuatan sekelompok utas, menetapkan prioritas mereka, dan mengelola bagaimana pekerjaan didistribusikan di antara utas tersebut. Saat beban kerja bertambah atau berkurang, kelas berputar atau menghancurkan lebih banyak utas untuk menyesuaikan dengan beban kerja.

 BlockingQueue workQueue= new LinkedBlockingQueue<Runnable>(100); // Work pool size
 ThreadPoolExecutor executor = new ThreadPoolExecutor(
            Runtime.getRuntime().availableProcessors(),       // Initial pool size
            Runtime.getRuntime().availableProcessors(),       // Max pool size
            1, // KEEP_ALIVE_TIME
            TimeUnit.SECONDS, //  KEEP_ALIVE_TIME_UNIT
            workQueue);

Anda bisa merujuk ke artikel panduan pengembang ini di create-threadpool untuk detail lebih lanjut.

Lihat posting ini untuk penggunaan Handlermenjalankan beberapa instance Runnable. Dalam hal ini, semua Runnabletugas akan berjalan dalam satu utas.

Android: Bersulang di utas

Handlerdapat digunakan bersamaan dengan Threaduntuk membuat mekanisme Antri. Anda dapat menggunakan handleruntuk memposting sesuatu di InternetThread Looper