O objetivo principal deste tutorial é mostrar um exemplo de processamento concorrente no Android, com compartilhamento simultâneo de dados.
Para isso vamos usar threads, sincronização, variável volatile e interrupt.
Aproveitando o teste, também usamos um ListAdapter customizado do BaseAdapter e as classes: Bundle, Message e Handler.
Vamos inicialmente montar um projeto que consiste em utilizar um objeto para controlar um contador sequencial, uma thread para usar o contador e enviar mensagens com o último número gerado no contador para a activity, esta receberá as mensagens e mostrará os números em uma ListView.
Vamos começar pelas telas. A tela main.xml, consiste em uma linha de status, dois botões de start e stop e a ListView que vai ser populada com o linhalista.xml que contém dois TextViews.

main.xml

linhalista.xml


Os dados que estamos tratando são o nome da Thread e o valor do contador. Usamos a classe Bundle para passar esses dois campos, e a classe Message para transferir o Bundle da thread para a activity via sendMessage da classe Handler. Na activity, o handler via handleMessage envia o Bundle para a lista e daí para a ListView.

Segue o ListAdapter: MyListAdapter.java

E o contador: ContadorSequencial.java

Na thread, é importantíssimo notar que a variável workThread é definida como volatile. Ela deve ser definida dessa forma para garantir que ao ser alterada por outra thread ela seja visível para a thread com as alterações, caso contrário a thread pode não encerrar nunca!
Segue a Thread: MyThread.java

Segue a activity: TesteThread03Activity.java

Nesse ponto, já podemos fazer um teste.
Veremos na tela a ListView sendo populada por uma sequencia de números vindo da thread.

Vamos fazer as seguintes alterações na activity:
Acrescentar essas variáveis:


Incluir no final do onCreate:


Incluir no iniciarThreads:


Incluir no pararThreads:

Faça um teste aqui.
Vemos que cada thread está usando um contador separado, cada um com sua própria sequencia.
E se pretendermos que seja uma contagem única? O quê precisamos fazer?
Primeiramente, devemos alterar a classe do contador para permitir compartilhamento seguro entre Threads, colocando a palavra synchronized nos métodos que acessam a variável contador. Isso vai garantir que quando estivermos acessando a variável por uma thread, uma outra que tentar acessar vai esperar a outra liberar.
Depois alterar a activity, e passar a mesma referência do objeto contador para as três threads.
ContadorSequencial.java


O método iniciarThreads, fica assim:

E testando, veremos uma sequencia única sendo enviados pelas três threads, compartilhando um único contador!

A H Gusukuma,

Ótimo tutorial!! Está de parabéns pelos constantes tutoriais de alto nível!!

Agora, aproveitando o assunto de thread, eu tenho uma dúvida, na verdade, um parêntese.

Ouço vários programadores dizendo e já li em vários lugares que usar "interrupt" ou "stop" em threads não é seguro. Eu mesmo já tive problema em algumas threads quando as finalizava dessa forma.

Nas minhas aplicações, sempre utilizo uma variável auxiliar para que as minhas threads terminem de maneira natural, ou seja, permitindo a saída de um "loop" infinito, e assim, terminando de executar todo o método "run()".

Por exemplo:


Como sei que vc conhece bem sobre threads, queria uma opinião sua. Como funciona esse tipo de coisa, é seguro ou não usar esses métodos??

Abraços!

Obrigado, antunes.

Na verdade o stop está banido, não apenas deprecated!
O interrupt é utilizado para interromper um sleep, por exemplo. Ele por si só não encerra a thread.
O teste seguinte é que vai interromper, já que antes a variável que controla o loop foi setado para null.
É obrigatório usar pelo menos volatile na variável que controla o loop.
Se não usar volatile, tem que usar synchronized no acesso à variável.
A forma como você colocou no exemplo pode ficar num loop infinito pois o compilador pode otimizar o código e colocar o while (!fim) numa parte da memória (registradores) e a alteração do método finalizar feito por outra thread nunca ficar visível para a sua thread.

Verifica que na rotina de shutDown, eu uso um artifício de salvar a referencia da thread numa variável local e depois setar a variável volatile que controla o fim do loop com null.

Veja esse link, o autor é especialista em Java.
http://www.ibm.com/developerworks/java/ ... index.html

A H Gusukuma,

Muito obrigado pela explicação!!

Dei uma lida em alguns materiais e entendi o que você fez, mas ainda não está suficientemente claro na minha cabeça. Garanto que lerei mais sobre o assunto.

Também não conhecia o modificador volatile, achei bem interessante o funcionamento dele. Acho que não tinha escutado falar dele pq ele tem uma função bem específica.

Já adianto pro pessoal que não é nada trivial, mas também não é impossível de se aprender!!

Os dias passam, lemos todos os dias, o dia inteiro e a gente descobre que não sabe quase nada. Brabo, né??

Vou até dar uma revisada no funcionamento das minhas threads e aproveitar pra aprender mais sobre o assunto!!

Abraços!!

Antunes,
O seu exemplo é bem mais intuitivo de entender, é só colocar o volatile na variável.

A forma que eu coloquei, não é tão perceptivel. Mas é muito utilizada, por isso eu coloquei assim. Se for ler códigos de outros programadores, é bem provavel de encontrar algo assim.

Agora, quanto a aprender algo novo, não tem como não ser assim. O Java é muito extenso.´
Eu tento compensar o fato de não saber muito, lendo o máximo que eu posso!

Eu uso volatile praticamente só nesse tipo de situação, como chave de dois estados. Mas é muito melhor do que usar uma variável com synchronized por ser mais leve num loop.

Muito Legal!