Android: Pourquoi ne puis-je pas créer un gestionnaire dans le nouveau thread

Vous pouvez également utiliser un HandlerThread comme ceci:

HandlerThread thread = new HandlerThread("MyHandlerThread");
thread.start();
Handler handler = new Handler(thread.getLooper());

HandlerThreads ont un Looper associés avec eux, de sorte à ne pas lever une exception.

Réponse courte: Parce que le fil que vous essayez de joindre le conducteur, qui n'a pas un looper. Et si le constructeur de la classe de Gestionnaire est en train de lancer une exception. Vous pourriez avoir utilisé un HandlerThread classe au lieu de cela, Ce est juste une pratique de classe fourni par l'Androïde cadre.

Veuillez lire ci-dessous de ce qui se passe sous le capot.

Permet d'abord d'essayer de discuter de toutes les pièces individuellement.

1. Fil:

un. Un thread est juste un flux d'exécution. Un thread par défaut est supposé exécuter son exécutable(si fourni) ou d'appeler sa méthode run. Sur appel de nouveau Thread.start(). Un thread juste meurt et Gc avais quand la méthode run exécute toutes les déclaration écrite à l'intérieur de la course(){ ---- }.

b. Il existe un concept de Looper dans Android. Ce qui rend fondamentalement le fil d'un blocage du thread. Mettre simplement, il n'a tout simplement pas laisser le fil de mourir. Il va dans un état de blocage et d'attente pour les plus de messages pour de nouveau reprendre son exécution.

Ci-dessous comment vous pouvez configurer un blocage de fil je.e un thread avec un looper.

  new Thread(new Runnable() {
    public void run() {
        Looper.prepare();
        Looper.loop();
    }
}).start();

Ici un thread est créé, ce qui ne veut pas mourir juste après l'exécution de la fonction Looper.loop() instruction. Au lieu de cela il fait une boucle et passe dans un état de blocage. Maintenant vous devez vous demander quel est le sens de l'état de blocage, comment le thread va sortir de l'état de blocage ? comment puis-je enfin à sortir de ce fil maintenant ? C'est là que Gestionnaire vient dans

1. Gestionnaire:

un. Il s'attache toujours à l'Arpenteuse de la fil, sur lequel une instance est créée.

b. Ensuite, il traite les messages du fil de discussion qu'il attache à l'.

Mettre ensemble thread et de gestionnaires.

new Thread(new Runnable() {
        public void run() {
            Looper.prepare();
            handler = new Handler();
            Looper.loop();
        }
    }).start();

un. Comment le gestionnaire obtient attaché à ce nouveau thread.
b. Le fil est configuré comme un blocage de boucleur. Ce n'est donc pas mourir.

maintenant, nous pouvons
1. Envoyez un message sur ce gestionnaire.
2. Post praticable sur ce gestionnaire.

Deux d'entre eux seront exécutés sur le fil.

Vous avez une option pour prolonger la classe de Gestionnaire et de mettre en œuvre la méthode handleMessage(Message msg). ou vous venez de fournir de la mise en œuvre de la Gestionnaire.Rappel dans le constructeur de la classe de gestionnaire. Dans les deux cas, le handleMessage(Messages msg) sera appelée sur le fil.

Pour quitter le fil, vous pouvez envoyer un type spécifique de type de message, et, après avoir reçu le message que vous voudrais simplement appeler la fonction Looper.myLooper().quit()

class LooperThread extends Thread {
   public Handler mHandler;

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

      mHandler = new Handler() {
          public void handleMessage(Message msg) {
              //process incoming messages here
              if(msg.what == -1){
              Looper.myLooper().quit();
              }
          }
      };

      Looper.loop();
   }
}

J'espère que cela a aidé à comprendre le concept global.