Capire cosa Looper è circa in Android

Question

ho dovuto aggiungere Looper al seguente codice:

public class MyRunnable implements Runnable 
{ 
    @Override 
    public void run() 
    { 
     Looper.prepare(); 
     final Looper looper = Looper.myLooper(); 

     new Handler().postDelayed(
      new Runnable() 
      { 
      @Override 
      public void run() 
      { 
       try 
       { 
       } 
       catch (Exception ex) 
       { 
       } 
       finally 
       { 
       looper.quit(); 
       } 
      } 
      }, 100); 

     Looper.loop(); 
    } 
} 

Si noti che ho un eseguibile all'interno di un eseguibile. Il runnable nidificato viene eseguito tramite un gestore. Inizialmente non avevo Looper, ma Android si è lamentato del fatto che dovevo chiamare Looper.prepare prima di eseguire un altro thread.

Ho letto su Looper ma sembra ancora un po 'criptico. Sembra comportarsi come una sorta di pipeline di messaggistica interna. Non mi è chiaro il motivo per cui ciò è necessario, dal momento che non ci sono messaggi che vanno dal mio percorso esteriore al mio gestibile interiore. Anche se questo è vero, sembra che Android stia semplicemente facendo la regola che se chiami un thread da un thread, DEVI chiamare anche Looper.prepare. Anche se accetto che così com'è, non aiuta ancora a capire perché devo chiamare looper.loop e looper.quit. Se ometto Looper.loop, il mio gestore non funziona mai e questo è ciò che non è chiaro. Che cosa fa Looper.loop che consente al mio gestore di funzionare?

Answer 1

Trovo il seguente tutorial molto utile per comprendere il concetto di looper.
Intro to looper and handler

Answer 2

Ecco un grande articolo a riguardo.

Looper and Handler in Android

Si arriva con un semplice schema che porta alla comprensione della relazione tra diritto e LoopersHandler.

Su questo schema, vediamo che, all'interno dello stesso filo (rappresentato dal grande rettangolo), non importa quante gestore si crea, saranno essere tutti utilizzano lo stesso Looper, vale a dire, il looper unico di questo thread.

Nota:

Looper deve essere prepared per consentire gestore associato per elaborare posted messages.

Applicazione Android, più precisamente, thread di interfaccia utente di app Android (il thread principale), già fornito con un looper preparato (il mainLooper).

Ecco come Communicating with the UI Thread.

Answer 3

Un concetto semplice del crochet:

1. Ogni thread di lavoro si crea e corsa si conclude una volta che esegue la sua ultima operazione.

2. Per impedire la terminazione del thread, è possibile avviare un ciclo chiamando Looper.loop(), considerandolo come while(true){}. Prima di chiamare Looper.loop() devi preparare il ciclo con Looper.prepare(), se non è ancora pronto. Per terminare il ciclo e terminare il thread è necessario chiamare looper.quit() sul looper.

Ora, per la notifica che hai da Android:

Quando si crea un Handler in un thread, che sarà legato al thread viene creato dentro e quando si posta eseguibile utilizzando questo gestore, il codice eseguito sul thread del gestore.

Così, quando il sistema ha visto che si desidera eseguire del codice (in particolare 100ms in futuro) su un gestore che è legato ad un filo che sta andando a morire non appena termina la chiamata al metodo post-it ha proposto di utilizzare Looper.loop() per impedire che questo thread si interrompa e quindi abilitare l'esecuzione corretta del secondo Runnable in un thread ancora esistente.