Programação Concorrente JAVA

1. Programação Concorrente JAVA Prof. Alexandre Monteiro Recife

2. Contatos • Prof. Guilherme Alexandre Monteiro Reinaldo • Apelido: Alexandre Cordel • E-mail/gtalk: alexandrecordel@gmail.com greinaldo@fbv.edu.br • Site: http://www.alexandrecordel.com.br/fbv • Celular: (81) 9801-1878

3. Conteúdo • O que é • Motivação • Conceitos • Processos • Threads • Propriedades • Safety • Liveness • Threads em JAVA

4. Programação Concorrente[ O que é ] • “Um programa concorrente é um conjunto de programas seqüenciais comuns que são executados em um paralelismo abstrato” (M.Bem-Ari)

5. Programação Concorrente[ O que é ] • “Um programa concorrente especifica 2 ou mais processos que cooperam para realizar uma tarefa. Processos cooperam através de comunicação; utilizam variáveis compartilhadas ou troca de mensagens“(G. R. Andrews)

6. Programação Concorrente[ Motivação ] • Aproveitar hardware com múltiplos processadores • Atender a vários usuários simultaneamente • Melhorar o desempenho das aplicações • Aumentar a disponibilidade da CPU para o usuário • Objetos ativos e controle de atividades • Programas paralelos

7. Programação Concorrente[ Conceitos ] • Paralelismo • Processamento simultâneo físico • Concorrência • Processamento simultâneo lógico (aparente) • Requer entrelaçamento (interleaving) de ações • Processo • Execução de um programa (running) • Programa Concorrente • Vários processos que cooperam para a realização de uma tarefa ou mais tarefas

8. Programação Concorrente[ Conceitos ] • Comunicação • Variáveis compartilhadas • Passagem de mensagens • Sincronização • Exclusão mútua de seções críticas • Sincronização por condição • Estado de um programa concorrente • Consiste dos valores das variáveis (explícitas e implícitas) • A execução de um comando muda o estado • Ações atômicas • Transformação indivisível de estado

9. Programação Concorrente[ Processos ] • Um processo é um programa que está em algum estado de execução • Tem espaço de endereçamento próprio, que é mapeado pelo S.O. para memória física • Possui um fluxo de controle ou thread único • Mantém um contador de programa (PC) que indica o endereço da próxima instrução • A MMU (Memory Management Unit) traduz os endereços lógicos em endereços físicos, que normalmente não são contíguos (Memória Virtual)

10. Pilha Heap Espaço de Endereçamento Lógico de um Processo Dados Globais Instruções Programação Concorrente[ Processos ] • Espaço de Endereçamento Lógico

11. Programação Concorrente[ Processos ] • Tabela de Processos • Estado do processo • Valores dos registradores • Arquivos abertos • Alocação de memória • PID (Process ID) • UID (User ID) • GID (Owner’s Group ID)

12. Programação Concorrente[ Processos ] • Estados de um processo • Iniciado (Start): processo criado • Executando (Running): Utilizando a CPU • Executável ou Pronto (Runnable ou Ready): Esperando para ser escalonado para usar a CPU • Suspenso (Suspended): Recebeu um sinal para ser suspenso • Bloqueado (Blocked): Esperando pela conclusão de algum serviço solicitado ao S.O. • Encerrado (Dead): processo morto

13. Ativo Bloqueado Executável Executando Iniciado Encerrado Suspenso Programação Concorrente[ Processos ]

14. Programação Concorrente[ Threads ] • Um processo pode ter mais de uma Thread (Linha) • Cada Thread possui contador de programa e pilha próprios • Quando um processo é escalonado para ser executado, uma das Threads entra em execução • As Threads compartilham as variáveis globais do processo

15. Programação Concorrente[ Threads ] Espaço de Endereçamento de um Processo Pilha Heap Thread 1 Thread n Thread 2 Pilha Contadorde Programa Pilha Contadorde Programa Pilha Contadorde Programa Variáveis Globais Instruções

16. Programação Concorrente[ Threads ] • Vantagens sobre processos compartilhando memória • São muito mais leves de serem criadas • A troca de contexto é mais suave pois compartilha instruções, heap e variáveis globais • Facilitam o compartilhamento de memória

17. Intervalo de tempo expirou Dormindo 4.sleep() Encerrada escalonada Criada Término Pronta Executando 2.start() interrompida 5.notify()5.notityAll() Operaçãode E/Siniciada Operaçãode E/Sconcluída Esperando Bloqueada Threads[ Ciclo de Vida ] 6.stop() 1.new Thread() 3.run() 4.wait()

18. Threads[ Sincronização ] • Sincronizando Threads • Programação com múltiplas Threads requer bastante cuidado: • Acesso / Atualização de variáveis compartilhadas • Starvation (processo nunca é executado) • Deadlock (impasse e dois ou mais processos ficam impedidos de continuar suas execuções e ficam bloqueados) • Acesso a estados inválidos de outros objetos

19. Threads[ Sincronização ] • A sincronização baseia-se na idéia de que para acessar um método sincronizado ou um entrar em um bloco sincronizado, é preciso obter (ou já ter) o lock desse objeto. • A Thread que conseguir esse lock é a única autorizada a acessar os recursos protegidos através de sincronização.

20. Programação Concorrente[ Propriedades ] • Safety: O programa nunca entra em um estado inconsistente • Liveness: Em algum momento o programa entra em um estado consistente • Correção Parcial: Se o programa terminar, o resultado está correto. Caso contrário, nunca pode dar o resultado correto • Término: O programa termina eventualmente • Ausência de Deadlock: Nunca todos os processos estarão bloqueados • Correção Total: O programa sempre termina e produz o resultado correto

21. Safety [ Introdução ] • Objetos interagindo em múltiplas Threads normalmente provocam interferência • Programas concorrentes devem possuir 2 propriedades: • Safety: Nada de mau acontecerá durante a execução do programa. • Liveness: Algo de bom acontecerá durante a execução do programa.

22. Safety [ Imutabilidade ] • Variáveis de instância constantes (final em Java) • Encapsulamento • Não requer sincronização • Classes sem estado (stateless) • Como não há estado, não há interferência

23. Safety [ Sincronização ] • Um Objeto/variável sempre está pronto para sofrer modificações, mesmo quando ainda está no meio do processamento de alguma • Acesso a estados inconsistentes devem ser evitados: • Conflitos de leitura/escrita: vários lêem enquanto um escreve • Conflitos de escrita/escrita: vários lêem e escrevem ao mesmo tempo

24. Safety [ Sincronização ] • No contexto de OO, podemos ter: • Sincronização Total • Objetos totalmente sincronizados. Podem fazer apenas uma operações por vez • Sincronização Parcial • Parte do objeto é sincronizado. Somente métodos sincronizados são travados

25. Safety [ Contenção ] • Baseia-se na idéia de manter referências únicas para objetos internos isolados dos demais. • São acessados apenas através de métodos sincronizados do objeto no qual estão contidos, estando, portanto, protegidos.

26. null serviço 1 null vizinho vizinho serviço 0 serviço 2 vizinho vizinho serviço 3 Recurso null Safety [ Contenção ] • É preciso definir um protocolo que garanta a exclusividade do recurso

27. Liveness [ Falhas de Liveness ] • São tão sérias quanto falhas de Safety • São mais difíceis de identificar e evitar durante o projeto • Tipos de falhas • Contenção: uma thread, apesar de estar pronta para executar, não executa porque outra tomou recursos (também conhecida como starvation ou adiamento infinito)

28. Liveness [ Falhas de Liveness ] • Dormência: uma thread não pronta falha ao tentar passar para esse estado. • Deadlock: duas ou mais threads bloqueiam-se em um ciclo vicioso enquanto tentam acessar travas sincronizadas necessárias para continuar suas atividades • Término prematuro: uma thread é parada ou encerrada prematuramente

29. Threads JAVA

30. Definições Básicas • Threads são sub-procesos no sistema operacional. • É menos custoso gerenciar threads do que processos. • As linguagens Java e Ada possuem funcionalidades MULTITHREADING na própria estrutura da linguagem. • C e C++ necessitam de biblioteca especifica para processamento MULTITHREADING • Posix p_thread

31. Diagrama de Estados Thread Java O diagrama mostra os estados de uma thread de Java pode estar e alguns métodos que podem ser usados para mudar de um estado para outro.

32. New Thread • Inicialização do thread - feita através do construtor Thread(). classMyThreadClassextends Thread{ ... } ... MyThreadClassmyThread = new MyThreadClass(); • Neste estado, nenhum recurso do sistema foi alocado para o thread ainda, assim, a partir daqui, tudo que você pode fazer é um start(), para ativar o thread, ou um stop(), para "matá-lo". • A chamada de qualquer outro método não faz sentido e levantará a exceção IllegalThreadStateException.

33. Runnable • Este é o estado em que o thread está pronto para rodar. O método start() requisita os recursos do sistema necessários para rodar o thread e chama o seu método run(). • O método run() é a "alma" de um thread; é neste método que definimos o que o thread vai executar. Thread myThread = new MyThreadClass(); myThread.start(); • Falamos em "Runnable", ao invés de "Running", porque o thread pode não estar realmente sendo executado. Imagine um computador com um único processador - seria impossível executar todos os threads "Runnable" ao mesmo tempo. O que ocorre é que a CPU deve ser escalonada entre os vários threads. • Quando um thread está "Running", ele está também "Runnable", e, as instruções do seu método run() é que estão sendo executadas pela CPU.

34. Not Runnable • O estado "Not Runnable" significa que o thread está impedido de executar por alguma razão. Existem 4 maneiras através das quais um thread ir para o estado "Not Runnable": • Alguém manda-lhe a mensagem suspend(). • Alguém manda-lhe a mensagem sleep(). • O thread bloqueia, esperando por I/O. • O thread usa seu método wait() para esperar por uma variável de condição.

35. Not Runnable • O exemplo abaixo coloca “myThread” para dormir por 10 segundos... Thread myThread = new MyThreadClass(); myThread.start(); try { myThread.sleep(10000); } catch (InterruptedException e){ }

36. Not Runnable • Cada uma destas maneiras tem a sua forma específica de sair do estado "Not Runnable". • Se o thread foi suspenso, alguém precisa mandar-lhe a mensagem resume(). • Se o thread foi posto para dormir, ele voltará a ser "Runnable" quando o número de milisegundos determinado passar. • Se o thread está bloqueado, esperando por I/O, a I/O precisa ser completada. • Se o thread está esperando por uma variável de condição, o objeto que a "segura" precisa liberá-la, através de um notify() ou de um notifyAll()

37. Dead • Um thread pode morrer de "causas naturais" (quando o seu método run() acaba normalmente) ou pode ser morto (AssAssINAdO pelo método stop()). Thread myThread = new MyThreadClass(); myThread.start(); publicvoidrun() { int i = 0; while (i < 100) { i++; System.out.println("i = " + i); } } • Este thread vai morrer naturalmente quando o loop do run() acabar.

38. Dead • O que vai acontecer com este thread? Thread myThread = new MyThreadClass(); myThread.start(); try { Thread.currentThread().sleep(10000); } catch (InterruptedException e){ } myThread.stop();

39. Método yield() • O método yield() • Cede a CPU para outros threads

40. Thread em Java • Em Java, threads são implementadas como uma CLASSE • Pacote java.lang.Thread • É uma extensão da classe Thread • Contrutores: • public Thread (String nome_da_thread); • public Thread ( ); // o nome sera Thread-# • Thread-1, Thread-2,…

41. Principais Métodos • run(): é o método que executa as atividades de uma THREAD. Quando este método finaliza, a THREAD também termina. • start(): método que dispara a execução de uma THREAD. Este método chama o método run( ) antes de terminar. • sleep(int x): método que coloca a THREAD para dormir por x milisegundos.

42. Principais Métodos • join( ): método que espera o término da THREAD para qual foi enviada a mensagem para ser liberada. • interrupt( ): método que interrompe a execução de uma THREAD. • interrupted( ): método que testa se uma THREAD está ou não interrompida.

43. Estados de uma Thread em Java nascimento Término do tempo de dormida start( ) Fim da E/S pronta notify( ) notifyAll( ) run( ) Alocar um processador executando E/S wait( ) sleep( ) stop( ) esperando dormindo morta bloqueada Fim do Método run( )

44. Prioridade de Thread • Em Java, a prioridade é determinada com um inteiro entre 1 e 10. • A prioridade padrão é o valor 5. • 10 é a maior prioridade e 1 é a menor. • A THREAD herda a prioridade da THREAD que acriou. • void setPriority(int prioridade); • int getPriority( );

45. A B Prioridade 10 Prioridade 9 C Prioridade 8 . . . Prioridade 3 D E F Prioridade 2 Prioridade 1 G Algoritmo de Escalonamento

46. Exercício 01 • O programa cria 04 threads e as coloca para dormir. • ThreadBasica é uma extensão da classe Thread.

47. Exercício 01 • Analisecomo se chama o métodosleep(). • Crien THREADs, onden é definidopelousuário. • Utilize o métodojoin no main para esperar as THREADs terminarem. try { uma_thread.join( ); // uma_thread.join(tempo) … }catch (InterruptedException e) { … }

48. A B Prioridade 10 Prioridade 9 C Prioridade 8 . . . Prioridade 3 D E F Prioridade 2 Prioridade 1 G Escalonamento de Threads

49. Exercício 02 • Prioridades de Threads • Utilize o método setPriority(int) para mudar a prioridade de threads • Utilize 01 thread com prioridade 1, 01 com prioridade 09 e as outras com prioridade 05. • Faça com que uma das threads de alta prioridade durma por 10 ms antes de terminar. • Faça com que outra thread de alta prioridade faça uma entrada de dado.

50. Exercício 03 • Problema Produtor X Consumidor • Com buffer de tamanho 1. • Variáveis compartilhadas. • A solução do problema seria utilizar-se duas THREADS: 01 consumidor e 01 produtor. • O que ocorre se não houver sincronização entre a leitura e escrita?