Vou postar o que (eu acho que) aprendi sobre o tema.
Para ficar mais interessante vou tentar fazer um paralelo
com a vida (quase) real.
Imaginem um estudante de programação de computadores que
resolve abrir uma empresa, empresa de desenvolvimento de sistemas, é claro.
O foco é desenvolver aplicações para dispositivos móveis,
para Android, é claro, novamente!
No começo, é uma empresa de um homem só. Como o seu nível de
conhecimento em programação Java é apenas um pouco além do básico, o destemido
desenvolvedor foca um nicho de mercado de pequenos utilitários. Com poucas telas e de programação mais simples.
Mas, com o tempo, com muito esforço e sorte, acaba recebendo
algumas encomendas mais sofisticadas, algumas até com conexão à internet.
O aplicativo funcionava muito bem, mas, tem sempre um mas...
Pediram uma versão para tablet, última geração, multi-core, Android 4...
Quando foi testar, recebeu uma mensagem estranha:
"android.os.NetworkOnMainThreadException".
Foi dar uma pesquisada no Google e encontrou a explicação: a
partir do Honeycomb, uma tentativa de executar uma conexão à internet estando
na Main Thread vai receber esse erro.
Como já tinha interesse em aprender programação concorrente,
resolveu estudar o assunto mais a fundo. Logo, encontrou um amigo que se dispôs
a ensinar...
Para encurtar a estória, teve que contratar uma
ajudante-geral, para atender os clientes enquanto estava fora.
Logo na primeira aula, ficou sabendo que em Java a classe
que permite fazer processamento concorrente é a classe Thread. Ao instanciar um
objeto thread, e dar start, uma linha de execução paralela é iniciada para
processar a tarefa.
O desenvolvedor notou, que isso era semelhante ao passar uma
tarefa para a ajudante, ele podia imediatamente fazer outras coisas enquanto
ela, em paralelo, executava a tarefa.
Verificou também que para saber se a thread já tinha
terminado, tinha algumas opções, como checar de tempo em tempo o status dela ou
fazer a própria thread avisar quando terminasse o serviço. Assim, como fazia com a ajudante. Apenas, que ela não era
tão educada quando era interrompida! Ela sempre dizia: quando eu terminar eu
aviso!
Às vezes ele passava uma tarefa para a ajudante e ficava
esperando ela terminar sem fazer nada, tal qual o programa quando usava um
myThread.join()...
Em outra aula, aprendeu sobre exclusão-mútua. A necessidade
de executar um pedaço do código de maneira exclusiva, ou seja, uma thread por
vez.
Esse tipo de necessidade, na empresa, ele teve com o uso do
lavatório. Quando era apenas ele, trancar a porta do lavatório só quando tinha
visita... Com a entrada da ajudante, tiveram que estabelecer certas
regras de convívio, quem tinha a posse da chave, tinha a exclusividade do
lavatório. Assim, muitos constrangimentos foram evitados...
No programa, também, quem tem a posse da trava tem acesso
exclusivo a um trecho de código. Assim, muitos erros são evitados.
No caso da visibilidade, as coisas são opostas, na empresa,
quem tem a chave tem onde se esconder, no programa quem tem a chave (quero
dizer, a trava) tem acesso às variáveis compartilhadas!
Quando estava estudando sobre problemas de compartilhamento
de variáveis e a obrigatoriedade de usar uma mesma trava, pensou, como seria
embaraçoso tentar implementar o uso de duas chaves para usar o
lavatório...
Na última sessão de estudos, o assunto foi a classe
AsyncTask, verificou que uma tarefa pode ser dividida em subtarefas quando
essas subtarefas precisam ser executadas em threads diferentes em momentos
diferentes.
Da mesma forma, como na empresa, assinar um documento é responsabilidade do desenvolvedor,
mas preencher pode ser executado pela ajudante.
Assim, acessar o servidor deve ser feito em outra thread,
mas, atualizar a tela é responsabilidade da Main Thread.
Abraços
Nenhum comentário:
Postar um comentário