Você pode entender melhor o que é Looper no contexto da estrutura da GUI. Looper é feito para fazer 2 coisas.
1) O Looper transforma um encadeamento normal , que termina quando o método run () retorna, em algo executado continuamente até o aplicativo Android ser executado , o que é necessário na estrutura da GUI (tecnicamente, ele ainda termina quando o método run () retorna. esclareça o que quero dizer abaixo).
2) O Looper fornece uma fila na qual os trabalhos a serem executados são enfileirados, o que também é necessário na estrutura da GUI.
Como você deve saber, quando um aplicativo é iniciado, o sistema cria um encadeamento de execução para o aplicativo, chamado “principal”, e os aplicativos Android normalmente executam inteiramente em um único encadeamento, por padrão, o “encadeamento principal”. Mas o tópico principal não é um tópico especial e secreto . É apenas um thread normal semelhante aos threads criados com o new Thread()código, o que significa que termina quando o método run () retorna! Pense no exemplo abaixo.
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();
}
}
Agora, vamos aplicar esse princípio simples aos aplicativos Android. O que aconteceria se um aplicativo Android fosse executado no encadeamento normal? Um thread chamado "main" ou "UI" ou o que quer que inicie seu aplicativo e desenha toda a interface do usuário. Portanto, a primeira tela é exibida para os usuários. E agora? O segmento principal termina? Não, não deveria. Deve esperar até que os usuários façam algo, certo? Mas como podemos alcançar esse comportamento? Bem, podemos tentar com Object.wait()ouThread.sleep(). Por exemplo, o encadeamento principal termina seu trabalho inicial para exibir a primeira tela e dorme. Ele acorda, o que significa interrompido, quando um novo trabalho é feito. Até aqui tudo bem, mas neste momento precisamos de uma estrutura de dados semelhante a uma fila para armazenar vários trabalhos. Pense em um caso em que um usuário toca na tela em série e uma tarefa leva mais tempo para ser concluída. Portanto, precisamos ter uma estrutura de dados para manter os trabalhos a serem executados da maneira primeiro a entrar, primeiro a sair. Além disso, você pode imaginar, implementar o encadeamento sempre em execução e processar o trabalho quando chegou usando interrupção não é fácil e leva a um código complexo e muitas vezes impossível de manter. Preferimos criar um novo mecanismo para esse fim, e é disso que Looper trata . O documento oficial da classe Looperdiz: "Os threads por padrão não têm um loop de mensagem associado a eles" e Looper é uma classe "usada para executar um loop de mensagem para um thread". Agora você pode entender o que isso significa.
Para deixar as coisas mais claras, vamos verificar o código em que o thread principal é transformado. Tudo acontece na classe ActivityThread . Em seu método main (), você pode encontrar o código abaixo, que transforma um thread principal normal em algo que precisamos.
public final class ActivityThread {
...
public static void main(String[] args) {
...
Looper.prepareMainLooper();
Looper.loop();
...
}
}
e Looper.loop()método fazem um loop infinito e desenfileiram uma mensagem e processam uma de cada vez:
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);
...
}
}
Portanto, basicamente Looper é uma classe criada para solucionar um problema que ocorre na estrutura da GUI. Mas esse tipo de necessidade também pode acontecer em outra situação. Na verdade, é um padrão bastante famoso para aplicativos multiencadeados e você pode aprender mais sobre isso em " Concurrent Programming in Java ", de Doug Lea (Especialmente, o capítulo 4.1.4 "Worker Threads" seria útil). Além disso, você pode imaginar que esse tipo de mecanismo não é exclusivo na estrutura do Android, mas toda a estrutura da GUI pode precisar de algo semelhante a isso. Você pode encontrar quase o mesmo mecanismo no framework Java Swing.
