Apa tujuan Looper dan bagaimana menggunakannya?

Saya baru mengenal Android. Saya ingin tahu apa yang dilakukan Looperkelas dan juga bagaimana menggunakannya. Saya telah membaca dokumentasi kelas Android Looper tetapi saya tidak dapat sepenuhnya memahaminya. Saya telah melihatnya di banyak tempat tetapi tidak dapat memahami tujuannya. Adakah yang bisa membantu saya dengan mendefinisikan tujuan Looperdan juga dengan memberikan contoh sederhana jika memungkinkan?

Apa itu Looper?

Looper adalah kelas yang digunakan untuk mengeksekusi Pesan (Runnables) dalam antrian. Utas normal tidak memiliki antrian seperti itu, mis. Utas sederhana tidak memiliki antrian apa pun. Ini dijalankan sekali dan setelah eksekusi metode selesai, utas tidak akan menjalankan Pesan lain (Dapat dijalankan).

Di mana kita bisa menggunakan kelas Looper?

Jika seseorang ingin menjalankan beberapa pesan (Runnables) maka ia harus menggunakan kelas Looper yang bertanggung jawab untuk membuat antrian di utas. Misalnya, saat menulis aplikasi yang mengunduh file dari internet, kita dapat menggunakan kelas Looper untuk meletakkan file yang akan diunduh dalam antrian.

Bagaimana itu bekerja?

Ada prepare()metode untuk mempersiapkan Looper. Kemudian Anda dapat menggunakan loop()metode untuk membuat loop pesan di utas saat ini dan sekarang Looper Anda siap untuk mengeksekusi permintaan dalam antrian sampai Anda keluar dari loop.

Berikut adalah kode yang dengannya Anda dapat mempersiapkan Looper.

class LooperThread extends Thread {
      public Handler mHandler;

      @Override
      public void run() {
          Looper.prepare();

          mHandler = new Handler() {
              @Override
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };

          Looper.loop();
      }
  }

Anda dapat lebih memahami apa itu Looper dalam konteks kerangka GUI. Looper dibuat untuk melakukan 2 hal.

1) Looper mengubah utas normal , yang berakhir ketika metode run () kembali, menjadi sesuatu yang berjalan terus menerus hingga aplikasi Android berjalan , yang diperlukan dalam kerangka GUI (Secara teknis, itu masih berakhir ketika metode run () kembali. jelaskan apa yang saya maksud di bawah).

2) Looper menyediakan antrian di mana pekerjaan yang harus dilakukan enqueued, yang juga diperlukan dalam kerangka GUI.

Seperti yang Anda ketahui, ketika aplikasi diluncurkan, sistem membuat utas eksekusi untuk aplikasi, yang disebut "utama", dan aplikasi Android biasanya berjalan seluruhnya pada satu utas secara default "utas utama". Tetapi utas utama bukanlah beberapa utas rahasia, khusus . Itu hanya utas normal yang mirip dengan utas yang Anda buat dengan new Thread()kode, yang berarti ia berhenti ketika metode run () kembali! Pikirkan contoh di bawah ini.

public class HelloRunnable implements Runnable {
    public void run() {
        System.out.println("Hello from a thread!");
    }

    public static void main(String args[]) {
        (new Thread(new HelloRunnable())).start();
    }
}

Sekarang, mari kita terapkan prinsip sederhana ini ke aplikasi Android. Apa yang akan terjadi jika aplikasi Android berjalan di utas normal? Utas yang disebut "utama" atau "UI" atau apa pun yang memulai aplikasi Anda, dan menggambar semua UI. Jadi, layar pertama ditampilkan kepada pengguna. Jadi bagaimana sekarang? Utas utama berakhir? Tidak, seharusnya tidak. Itu harus menunggu sampai pengguna melakukan sesuatu, bukan? Tetapi bagaimana kita bisa mencapai perilaku ini? Ya, kita bisa coba dengan Object.wait()atauThread.sleep(). Misalnya, utas utama menyelesaikan pekerjaan awalnya untuk menampilkan layar pertama, dan tidur. Bangun, yang berarti terganggu, ketika pekerjaan baru dilakukan diambil. Sejauh ini bagus, tetapi saat ini kita membutuhkan struktur data seperti antrian untuk menampung banyak pekerjaan. Pikirkan suatu kasus ketika pengguna menyentuh layar secara seri, dan tugas membutuhkan waktu lebih lama untuk diselesaikan. Jadi, kita perlu memiliki struktur data untuk menahan pekerjaan yang harus dilakukan dengan cara masuk pertama keluar pertama. Juga, Anda mungkin membayangkan, mengimplementasikan utas yang selalu berjalan dan proses-kerja-saat-tiba menggunakan interupsi tidak mudah, dan mengarah pada kode yang kompleks dan sering kali tidak dapat dipertahankan. Kami lebih suka membuat mekanisme baru untuk tujuan tersebut, dan itulah yang menjadi tujuan Looper . The dokumen resmi kelas Loopermengatakan, "Utas secara default tidak memiliki loop pesan yang dikaitkan dengan mereka", dan Looper adalah kelas "yang digunakan untuk menjalankan loop pesan untuk utas". Sekarang Anda bisa mengerti artinya.

Agar lebih jelas, mari kita periksa kode di mana utas utama diubah. Itu semua terjadi di kelas ActivityThread . Dalam metode main (), Anda dapat menemukan kode di bawah ini, yang mengubah utas utama normal menjadi sesuatu yang kita butuhkan.

public final class ActivityThread {
    ...
    public static void main(String[] args) {
        ...
        Looper.prepareMainLooper();
        Looper.loop();
        ...
    }
}

dan Looper.loop()metode loop tanpa batas dan membagikan pesan dan memproses satu per satu:

public static void loop() {
    ...
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
        ...
        msg.target.dispatchMessage(msg);
        ...
    }
}

Jadi, pada dasarnya Looper adalah kelas yang dibuat untuk mengatasi masalah yang terjadi dalam kerangka GUI. Tetapi kebutuhan semacam ini juga dapat terjadi dalam situasi lain juga. Sebenarnya ini adalah pola yang cukup terkenal untuk aplikasi multi-threads, dan Anda dapat mempelajari lebih lanjut tentang itu di " Concurrent Programming in Java " oleh Doug Lea (Terutama, bab 4.1.4 "Worker Threads" akan sangat membantu). Anda juga dapat membayangkan mekanisme semacam ini tidak unik dalam kerangka Android, tetapi semua kerangka kerja GUI mungkin perlu sedikit mirip dengan ini. Anda dapat menemukan mekanisme yang hampir sama dalam kerangka Java Swing.

Looper memungkinkan tugas dieksekusi secara berurutan pada satu utas. Dan pawang mendefinisikan tugas-tugas yang perlu kita jalankan. Ini adalah skenario khas yang saya coba ilustrasikan dalam contoh ini:

class SampleLooper extends Thread {
@Override
public void run() {
  try {
    // preparing a looper on current thread     
    // the current thread is being detected implicitly
    Looper.prepare();

    // now, the handler will automatically bind to the
    // Looper that is attached to the current thread
    // You don't need to specify the Looper explicitly
    handler = new Handler();

    // After the following line the thread will start
    // running the message loop and will not normally
    // exit the loop unless a problem happens or you
    // quit() the looper (see below)
    Looper.loop();
  } catch (Throwable t) {
    Log.e(TAG, "halted due to an error", t);
  } 
}
}

Sekarang kita bisa menggunakan handler di beberapa utas lainnya (misalkan ui utas) untuk mengirim tugas pada Looper untuk dieksekusi.

handler.post(new Runnable()
{
public void run() {
//This will be executed on thread using Looper.
    }
});

Di utas UI kami memiliki Looper implisit yang memungkinkan kami menangani pesan di utas ui.

Android Looperadalah pembungkus untuk melampirkan MessageQueueke Threaddan mengelola pengolahan Queue. Itu terlihat sangat samar dalam dokumentasi Android dan sering kali kita mungkin menghadapi Loopermasalah akses UI terkait. Jika kita tidak memahami dasar-dasarnya, itu menjadi sangat sulit untuk ditangani.

Berikut ini adalah artikel yang menjelaskan Loopersiklus hidup, cara menggunakannya dan penggunaan LooperdalamHandler

Looper = Utas + MessageQueue

Definisi Looper & Handler:

Looper adalah kelas yang mengubah utas menjadi Pipeline Thread dan Handler memberi Anda mekanisme untuk mendorong tugas ke dalamnya dari utas lainnya.

Detail:

Jadi Thread PipeLine adalah utas yang dapat menerima lebih banyak tugas dari utas lainnya melalui Handler.

The Looper diberi nama demikian karena mengimplementasikan loop - mengambil tugas berikutnya, mengeksekusinya, kemudian mengambil yang berikutnya dan seterusnya. Handler disebut handler karena digunakan untuk menangani atau menerima tugas berikutnya setiap kali dari utas lainnya dan meneruskan ke Looper (Utas atau Utas Pipa Pipa).

Contoh:

Contoh Looper dan Handler atau PipeLine Thread yang sangat sempurna adalah mengunduh lebih dari satu gambar atau mengunggahnya ke server (Http) satu per satu di utas tunggal alih-alih memulai Utas baru untuk setiap panggilan jaringan di latar belakang.

Baca lebih lanjut di sini tentang Looper dan Handler dan definisi dari Pipeline Thread:

Android Guts: Intro to Loopers and Handler

Sebuah Looper memiliki synchronized MessageQueueyang digunakan untuk proses Pesan ditempatkan pada antrian.

Ini mengimplementasikan ThreadPola Penyimpanan Khusus.

Hanya satu Looperper Thread. Metode utama meliputi prepare(), loop()dan quit().

prepare()menginisialisasi arus Threadsebagai Looper. prepare()adalah staticmetode yang menggunakan ThreadLocalkelas seperti yang ditunjukkan di bawah ini.

   public static void prepare(){
       ...
       sThreadLocal.set
       (new Looper());
   }

1. prepare() harus dipanggil secara eksplisit sebelum menjalankan loop acara.
2. loop()menjalankan loop acara yang menunggu Pesan tiba di pesan Thread tertentu. Setelah Pesan berikutnya diterima, loop()metode ini mengirimkan Pesan ke penangan targetnya
3. quit()mematikan loop acara. Itu tidak mengakhiri loop, tetapi sebaliknya enqueues pesan khusus

Looperdapat diprogram dalam Threadbeberapa langkah

1. Memperpanjang Thread

2. Panggil Looper.prepare()untuk menginisialisasi Utas sebagai aLooper

3. Buat satu atau lebih Handleruntuk memproses pesan yang masuk

4. Panggil Looper.loop()untuk memproses pesan sampai loop diberitahu quit().

Rentang hidup java Thread selesai setelah penyelesaian run()metode. Utas yang sama tidak dapat dimulai lagi.

Looper mengubah normal Threadmenjadi loop pesan. Metode utama Looperadalah:

void prepare ()

Inisialisasi utas saat ini sebagai looper. Ini memberi Anda kesempatan untuk membuat penangan yang kemudian mereferensikan looper ini, sebelum benar-benar memulai loop. Pastikan untuk memanggil loop () setelah memanggil metode ini, dan akhiri dengan memanggil quit ().

void loop ()

Jalankan antrian pesan di utas ini. Pastikan untuk memanggil quit () untuk mengakhiri loop.

void quit()

Keluar dari looper.

Menyebabkan metode loop () berhenti tanpa memproses pesan lagi dalam antrian pesan.

Ini mindorks Artikel oleh Janishar menjelaskan konsep inti dalam cara yang baik.

Looperdikaitkan dengan sebuah Thread. Jika Anda membutuhkan Looperutas UI, Looper.getMainLooper()akan mengembalikan utas terkait.

Anda harus Looperdikaitkan dengan Handler .

Looper,, Handlerdan HandlerThreadmerupakan cara Android untuk memecahkan masalah pemrograman asinkron.

Setelah melakukannya Handler, Anda dapat menghubungi API di bawah ini.

post (Runnable r)

Menyebabkan Runnable r ditambahkan ke antrian pesan. Runnable akan dijalankan pada utas yang dilampirkan pawang ini.

boolean sendMessage (Message msg)

Mendorong pesan ke akhir antrian pesan setelah semua pesan menunggu sebelum waktu saat ini. Ini akan diterima di handleMessage (Pesan), di utas yang terlampir pada penangan ini.

HandlerThread adalah kelas praktis untuk memulai utas baru yang memiliki looper. Looper kemudian dapat digunakan untuk membuat kelas handler

Dalam beberapa skenario, Anda tidak dapat menjalankan Runnabletugas di UI Thread. mis. Operasi jaringan: Kirim pesan pada soket, buka URL dan dapatkan konten dengan membacaInputStream

Dalam hal ini, HandlerThreadberguna. Anda bisa mendapatkan Looperobjek dari HandlerThreaddan membuat Handleron HandlerThreadsebagai ganti utas utama.

The HandlerThread kode akan menjadi seperti ini:

@Override
public void run() {
    mTid = Process.myTid();
    Looper.prepare();
    synchronized (this) {
        mLooper = Looper.myLooper();
        notifyAll();
    }
    Process.setThreadPriority(mPriority);
    onLooperPrepared();
    Looper.loop();
    mTid = -1;
}

Lihat posting di bawah ini sebagai contoh kode:

Android: Bersulang di utas

Memahami Thread Looper

A java Thread unit eksekusi yang dirancang untuk melakukan tugas dalam metode run () & berakhir setelah itu:

Tetapi di Android ada banyak kasus penggunaan di mana kita perlu menjaga agar Thread tetap hidup dan menunggu input / peristiwa pengguna misalnya. Utas UI alias Main Thread.

Utas utama di Android adalah utas Java yang pertama kali dimulai oleh JVM pada saat peluncuran aplikasi dan terus berjalan hingga pengguna memilih untuk menutupnya atau menemukan pengecualian yang tidak ditangani.

Ketika suatu aplikasi diluncurkan, sistem membuat utas eksekusi untuk aplikasi tersebut, yang disebut "utama." Utas ini sangat penting karena bertanggung jawab atas pengiriman acara ke widget antarmuka pengguna yang sesuai, termasuk menggambar acara.

Sekarang yang perlu diperhatikan di sini adalah meskipun utas utama adalah utas Java namun tetap mendengarkan acara pengguna dan menggambar 60 fps bingkai di layar dan tetap tidak akan mati setelah setiap siklus. bagaimana bisa begitu?

Jawabannya adalah Kelas Looper : Looper adalah kelas yang digunakan untuk menjaga utas tetap hidup dan mengelola antrian pesan untuk menjalankan tugas pada utas itu.

Utas secara default tidak memiliki loop pesan yang terkait dengannya tetapi Anda dapat menetapkannya dengan memanggil Looper.prepare () dalam metode jalankan dan kemudian memanggil Looper.loop ().

Tujuan dari Looper adalah untuk menjaga agar Thread tetap hidup dan menunggu siklus Messageobjek input berikutnya untuk melakukan komputasi yang jika tidak akan hancur setelah siklus pertama eksekusi.

Jika Anda ingin menggali lebih dalam bagaimana Looper mengelola Messageantrian objek maka Anda dapat melihat pada kode sumber Looperclass:

https://github.com/aosp-mirror/platform_frameworks_base/blob/master/core/java/android/os/Looper.java

Di bawah ini adalah contoh bagaimana Anda dapat membuat Looper Threaddan berkomunikasi dengan Activitykelas menggunakanLocalBroadcast

class LooperThread : Thread() {

    // sendMessage success result on UI
    private fun sendServerResult(result: String) {
        val resultIntent = Intent(ServerService.ACTION)
        resultIntent.putExtra(ServerService.RESULT_CODE, Activity.RESULT_OK)
        resultIntent.putExtra(ServerService.RESULT_VALUE, result)
        LocalBroadcastManager.getInstance(AppController.getAppController()).sendBroadcast(resultIntent)
    }

    override fun run() {
        val looperIsNotPreparedInCurrentThread = Looper.myLooper() == null

        // Prepare Looper if not already prepared
        if (looperIsNotPreparedInCurrentThread) {
            Looper.prepare()
        }

        // Create a handler to handle messaged from Activity
        handler = Handler(Handler.Callback { message ->
            // Messages sent to Looper thread will be visible here
            Log.e(TAG, "Received Message" + message.data.toString())

            //message from Activity
            val result = message.data.getString(MainActivity.BUNDLE_KEY)

            // Send Result Back to activity
            sendServerResult(result)
            true
        })

        // Keep on looping till new messages arrive
        if (looperIsNotPreparedInCurrentThread) {
            Looper.loop()
        }
    }

    //Create and send a new  message to looper
    fun sendMessage(messageToSend: String) {
        //Create and post a new message to handler
        handler!!.sendMessage(createMessage(messageToSend))
    }


    // Bundle Data in message object
    private fun createMessage(messageToSend: String): Message {
        val message = Message()
        val bundle = Bundle()
        bundle.putString(MainActivity.BUNDLE_KEY, messageToSend)
        message.data = bundle
        return message
    }

    companion object {
        var handler: Handler? = null // in Android Handler should be static or leaks might occur
        private val TAG = javaClass.simpleName

    }
}

Penggunaan :

 class MainActivity : AppCompatActivity() {

    private var looperThread: LooperThread? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // start looper thread
        startLooperThread()

        // Send messages to Looper Thread
        sendMessage.setOnClickListener {

            // send random messages to looper thread
            val messageToSend = "" + Math.random()

            // post message
            looperThread!!.sendMessage(messageToSend)

        }   
    }

    override fun onResume() {
        super.onResume()

        //Register to Server Service callback
        val filterServer = IntentFilter(ServerService.ACTION)
        LocalBroadcastManager.getInstance(this).registerReceiver(serverReceiver, filterServer)

    }

    override fun onPause() {
        super.onPause()

        //Stop Server service callbacks
     LocalBroadcastManager.getInstance(this).unregisterReceiver(serverReceiver)
    }


    // Define the callback for what to do when data is received
    private val serverReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            val resultCode = intent.getIntExtra(ServerService.RESULT_CODE, Activity.RESULT_CANCELED)
            if (resultCode == Activity.RESULT_OK) {
                val resultValue = intent.getStringExtra(ServerService.RESULT_VALUE)
                Log.e(MainActivity.TAG, "Server result : $resultValue")

                serverOutput.text =
                        (serverOutput.text.toString()
                                + "\n"
                                + "Received : " + resultValue)

                serverScrollView.post( { serverScrollView.fullScroll(View.FOCUS_DOWN) })
            }
        }
    }

    private fun startLooperThread() {

        // create and start a new LooperThread
        looperThread = LooperThread()
        looperThread!!.name = "Main Looper Thread"
        looperThread!!.start()

    }

    companion object {
        val BUNDLE_KEY = "handlerMsgBundle"
        private val TAG = javaClass.simpleName
    }
}

Bisakah kita menggunakan tugas Async atau Layanan Intent saja?

• Tugas Async dirancang untuk melakukan operasi singkat di latar belakang dan memberikan kemajuan & hasil pada utas UI. Tugas Async memiliki batas seperti Anda tidak dapat membuat lebih dari 128 tugas Async dan ThreadPoolExecutorhanya mengizinkan hingga 5 tugas Async .

• IntentServicesjuga dirancang untuk melakukan tugas latar belakang untuk durasi yang sedikit lebih lama dan Anda dapat menggunakannya LocalBroadcastuntuk berkomunikasi Activity. Tetapi layanan hancur setelah eksekusi tugas. Jika Anda ingin tetap berjalan untuk waktu yang lama daripada yang Anda perlu lakukan sih while(true){...}.

Kasus penggunaan bermakna lainnya untuk Looper Thread:

• Digunakan untuk komunikasi soket 2 arah di mana server terus mendengarkan soket Klien dan menulis kembali pengakuan

• Pemrosesan bitmap di latar belakang. Lewati url gambar ke thread Looper dan itu akan menerapkan efek filter dan menyimpannya di lokasi tempe rory dan kemudian menyiarkan jalur temp gambar.

Jawaban ini tidak ada hubungannya dengan pertanyaan, tetapi penggunaan looper dan cara orang menciptakan handler dan looper dalam SEMUA jawaban di sini adalah praktik buruk yang sebenarnya (beberapa penjelasan benar), saya harus memposting ini:

HandlerThread thread = new HandlerThread(threadName);
thread.start();
Looper looper = thread.getLooper();
Handler myHandler = new Handler(looper);

dan untuk implementasi penuh

Menangani beberapa item ke bawah atau mengunggah dalam Layanan adalah contoh yang lebih baik.

Handlerdan AsnycTasksering digunakan untuk menyebarkan Acara / Pesan antara UI (utas) dan utas pekerja atau untuk menunda tindakan. Jadi mereka lebih terkait dengan UI.

A Loopermenangani tugas ( Runnables, Futures ) dalam antrian terkait thread di latar belakang - bahkan tanpa interaksi pengguna atau UI yang ditampilkan (aplikasi mengunduh file di latar belakang selama panggilan).

Apa itu Looper?

DARI DOK

Looper

LooperKelas yang digunakan untuk menjalankan loop pesan untuk a thread. Utas secara default tidak memiliki loop pesan yang terkait dengannya; untuk membuat satu, panggil prepare()utas yang akan menjalankan loop, dan kemudian loop()untuk memproses pesan sampai loop dihentikan.

• A Looperadalah loop penanganan pesan:
• Karakter penting dari Looper adalah bahwa ia terkait dengan utas tempat Looper dibuat
• Kelas Looper mempertahankan a MessageQueue, yang berisi daftar pesan. Karakter penting dari Looper adalah bahwa ia terkait dengan utas tempat Looper dibuat.
• The Looperbernama jadi karena mengimplementasikan loop - mengambil tugas berikutnya, mengeksekusinya, kemudian mengambil yang berikutnya dan seterusnya. Ini Handlerdisebut pawang karena seseorang tidak dapat menemukan nama yang lebih baik
• Android Looperadalah kelas Java dalam antarmuka pengguna Android yang bersama-sama dengan kelas Handler untuk memproses acara UI seperti klik tombol, redraws layar dan sakelar orientasi.

Bagaimana itu bekerja?

Menciptakan Looper

Sebuah utas mendapat Looperdan MessageQueuedengan menelepon Looper.prepare()setelah dijalankan. Looper.prepare()mengidentifikasi utas panggilan, membuat Looper dan MessageQueueobjek dan mengaitkan utas

KODE SAMPEL

class MyLooperThread extends Thread {

      public Handler mHandler; 

      public void run() { 

          // preparing a looper on current thread  
          Looper.prepare();

          mHandler = new Handler() { 
              public void handleMessage(Message msg) { 
                 // process incoming messages here
                 // this will run in non-ui/background thread
              } 
          }; 

          Looper.loop();
      } 
  }

Untuk informasi lebih lanjut, periksa pos di bawah ini

• Apa hubungan antara Looper, Handler dan MessageQueue di Android?
• Android Guts: Intro to Loopers and Handler
• Memahami Android Core: Looper, Handler, dan HandlerThread
• Handler di Android
• Apa itu Android Looper?
• Android: Looper, Handler, HandlerThread. Bagian I.
• MessageQueue dan Looper di Android