Tutorial Android: Paralelismo – Threads

On 7 de dezembro de 2014 by admin

Captura de Tela 2014-11-28 às 08.13.51

Neste post iremos apresentar as threads básicas no Android.

 

Quando uma aplicação é iniciada, o sistema cria uma thread de execução para o aplicativo, chamada de “main”. Essa thread é muito importante, pois é responsável por despachar eventos para os widgets de interface de usuário, incluindo eventos de desenho. Ela também é a thread em que seu aplicativo interage com os componentes do kit de ferramentas UI Android (componentes das embalagens android.widget e android.view). Como tal, o segmento principal também é chamado às vezes o UI Thread.

Quando o usuário toca um botão na tela, a UI Thread despacha o evento de toque para o widget, que por sua vez define seu estado pressionado e posta um pedido  para a fila de eventos. A UI Thread desenfileira o pedido e notifica o widget que ele deve se redesenhar. Quando seu aplicativo realiza um trabalho intensivo em resposta à interação do usuário, este modelo único de thread pode render um desempenho ruim. Especificamente, se tudo está acontecendo na UI Thread, executando operações longa pode ocorrer o bloqueio de toda a UI. Além disso, o framework da UI Android não é thread-safe. Assim, você não deve manipular a interface do usuário a partir de uma thread de background-você deve fazer toda a manipulação de sua interface de usuário do UI Thread. Assim, temos as restrições:

  • Não bloqueie a UI Thread.
  • Não acesse o kit de ferramentas UI Android de fora da interface do usuário.

Para permitir a execução em background vamos apresentar dois componentes, os mais básicos, o Runnable e a Thread.

 

Runnable

Representa um comando que pode ser executado numa Thread. Possui apenas um método (public abstract void run ()). Um exemplo de uso deste método seria

public class ExemploRunnable implements Runnable {
    ...
    @Override
    public void run() {
        /*
         * Código que será executado dentro da Thread
         */
        ...
    }
    ...
}

 

Thread

A thread tem a sua própria pilha de chamadas para os métodos que forem invocados, assim como os seus argumentos e variáveis locais. Cada aplicação tem pelo menos uma thread em execução quando for iniciada, a thread principal, no ThreadGroup principal.

Há duas maneiras de executar um código em uma nova thread. Você pode herdar uma thread e substituir seu método run (), ou construir uma novo thread e passar um Runnable para o construtor. Em ambos os casos, o método start () deve ser chamado para realmente executar o novo Thread.

 

Exemplos

Abaixo um exemplo de uma thread em execução.

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class TesteActivity extends Activity {

public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);


new Thread(new Runnable() {
public void run(){
        /*
         * Código que será executado dentro da Thread
         */
}
}).start();

}

}

O problema com este modelo de Threads é a inexistência de uma política de cancelamento da mesma. Qualquer controle se resume ao reinicio da mesma, após sua finalização, sendo esta também não gerenciavel.

Além disso, seu processamento em background não será compatível com o acesso da UI Thread. Por exemplo, o código abaixo

 

public void onClick(View v) {
    new Thread(new Runnable() {
        public void run() {
            Bitmap b = loadImageFromNetwork("http://example.com/image.png");
            mImageView.setImageBitmap(b);
        }
    }).start();
}

Irá causar o travamento, pois está violando a regra de processamento com a UI Thread. Uma possível correção do código consiste em:

 

 

public void onClick(View v) {
    new Thread(new Runnable() {
        public void run() {
            final Bitmap bitmap = loadImageFromNetwork("http://example.com/image.png");
            mImageView.post(new Runnable() {
                public void run() {
                    mImageView.setImageBitmap(bitmap);
                }
            });
        }
    }).start();
}

Neste caso o método View.post() faz com que o código de atualização execute dentro da UI Thread, isolando a thread de acesso a rede da thread de acesso a interface com o usuário.

 

Referências

 

[1]http://developer.android.com/guide/components/processes-and-threads.html

[2]https://developer.android.com/training/multiple-threads/define-runnable.html

Trackbacks & Pings

Deixe um comentário

O seu endereço de e-mail não será publicado.