Programação Paralela - Threads

Loading...

Flash Player 9 (or above) is needed to view presentations.
We have detected that you do not have it on your computer. To install it, go here.

1 comments

Comments 1 - 1 of 1 previous next Post a comment

  • + heltonritter Helton Ritter 7 months ago
    Legal, minha primeira leitura sobre programação paralela/distribuida em java. Obrigado por compartilhar os slides.
Post a comment
Embed Video
Edit your comment Cancel

1 Favorite

Programação Paralela - Threads - Presentation Transcript

  1. Programação Paralela - Threads Glaucio Scheibel - GUJava/SC
  2. O que é uma Thread?
    • Java é um computador virtual e Thread é a sua CPU virtual.
    • Num computador virtual podemos ter quantas CPU’s virtuais quisermos.
  3. Thread: Outras definições
    • Divisão de um processo. SubProcesso.
    • Linha de execução.
  4. Tipos de Processo: CPU x IO
    • CPU Bound: processo que se utiliza principalmente de cálculos, dependendo totalmente da CPU. Ex: CAD, Jogos.
    • IO Bound: processo que depende principalmente de externos (disco, banco de dados, rede, usuário). Ex: Proc. de dados, ERP, CRM.
  5. Por que usar Thread’s
    • Em aplicações IOBound , que muitas vezes é o mais comum que trabalhamos, desperdiçamos poderosos recursos computacionais na espera deste IO.
    • CPU adquirida e sub-utilizada é perda de dinheiro.
  6. A pergunta que não quer calar
    • Por que processar um a um, se podemos forçar a CPU e processar dois a dois ou três a três ou sei lá, Dez, Cem, Duzentos, Mil!
    • Ou até tudo de uma só vez.
    • Ex clássico: Calculo da folha de pagamento.
  7. Programa sem Threads
  8. Programa com Threads
  9. Concorrência X Paralelismo Tarefa Tarefa Tempo Tempo
  10. Concorrência X Paralelismo
    • Para termos a real paralelismo, precisamos ter mais de uma CPU física e um sistema operacional que as suporte.
    • Muitas vezes não há a opção, o sistema possui um modelo, e na programação isto deve estar previsto.
  11. Scheduler / Escalonador
    • Função do sistema operacional que define qual dos processos em execução poderá utilizar-se da CPU.
    • Difere de sistema operacional para sistema operacional.
  12. Modelos de Thread
    • Cooperativo
    • Preemptivo
  13. Modelo Cooperativo
    • As Thread’s devem cooperar umas com as outras, usando um pouco da CPU de cada vez.
    • Fica a cargo das thread’s passar a vez.
    • Reduz problemas de sincronização.
    • Baseado puramente em prioridades.
  14. Modelo Cooperativo
    • Vantagens:
      • Maior velocidade com menos overhead.
    • Problemas:
      • Thread’s podem tornar-se selfish, ou seja, não liberar mais a CPU.
      • Thread’s de menor prioridade podem entrar em starvation , ou seja, não conseguir mais acesso a CPU .
  15. Modelo Preemptivo
    • O sistema operacional utiliza uma espécie de timer para chavear as thread’s. Cada intervalo de execução é chamado de Timer Slice.
    • Quando uma thread recebe a CPU, já esta pré-definido este tempo de uso.
  16. Modelo Preemptivo
    • Vantagens:
      • Facilidade de programação.
      • Teoricamente evita starvation.
    • Problemas:
      • Menos eficiente devido as thread’s serem gerenciadas pelo sistema operacional.
      • Necessita de controle de sincronização.
  17. Sun Solaris
    • Modo preemptivo para processos e modo cooperativo para Threads.
    • 2 31 níveis de prioridade.
    • Administrador pode restringir o nível de prioridade dos processos do usuário.
  18. Microsoft Windows NT
    • Modo preemptivo para processos e threads.
    • 7 níveis de prioridade.
    • Priority Boosting (acessível via C).
  19. Java
    • 10 níveis de prioridade
    • Na maioria dos casos, o Java mapeia suas próprias threads para threads do sistema operacional. Depende da implementação da VM (JRockit).
  20. Considerações na Codificação
    • Assuma o pior caso:
      • Posso ser preemptado a qualquer momento.
      • Posso ser egoísta ( selfish ).
      • Darei preferência as prioridades 1, 5 e 10; pois pode ser que a prioridade 10 não seja maior que a prioridade 9.
  21. Partes de uma Thread Java
  22. Criando o Código da Thread
    • public class Contador implements Runnable {
    • private int id;
      • public void run() {
        • for (int i=1; i <= 10; i++) {
          • System.out.println(“i=“ + i);
        • }
      • }
    • }
  23. Criando a CPU de uma Thread
    • public class Teste {
    • public static void main(String[] args) {
    • Contador c = new Contador();
    • Thread t = new Thread(c);
    • }
    • }
  24. Dados
    • Lembra da variável local “i”?
      • for (int i =1; i <= 10; i ++) {
        • System.out.println(“i=“ + i );
      • }
    • Variáveis locais são armazenadas nas Threads
  25. Compartilhamento
    • Diferentes Threads podem compartilhar o mesmo código:
      • Thread t1 = new Thread( c );
      • Thread t2 = new Thread( c );
      • Thread t3 = new Thread( c );
  26. Estados da Thread Pronto Rodando Bloqueada
  27. Cooperativo: Passando a Vez
    • Thread.sleep(long milesegundos)
      • para a execução da Thread por um tempo pré-determinado.
    • Thread.yield()
      • passa a vez para outra Thread de igual ou maior prioridade.
  28. Preemptivo: Sincronização
    • Mecanismo para evitar corrupção dos dados num ambiente multi-thread preemptivo.
    • Membros dos objetos podem estar sendo invocados simultaneamente por n Threads, sem a certeza de seu término antes da preempção.
  29. Preemptivo: Objeto Monitor
    • Objeto utilizado para servir de semáforo.
    • Cada objeto possui um flag que determina qual thread tem o acesso exclusivo.
    • Similar à lock de registro num banco de dados
  30. Preemptivo: Sincronização
    • Modificador synchronized.
      • O próprio objeto é o monitor.
    • synchronized(Object o) {}.
      • Bloco sincronizado especificando qual o objeto monitor.
  31. Estados da Thread - Sincronização Pronto Rodando Bloqueada Travada
  32. Notificação de recurso
    • Muitas vezes a Thread recebe a CPU, mas não há recursos para executar.
    • A Thread pode registrar-se para receber uma notificação.
    • Sempre ligado a um bloco sincronizado.
  33. Notificação de recurso
    • this.wait()
      • Aguarda a notificação.
    • this.notify()
      • Notifica uma das Threads (não é possível dizer qual) que estão aguardando.
    • this.notifyAll()
      • Notifica todas as Threads que estão aguardando.
  34. Estados da Thread - Sincronização Pronto Rodando Bloqueada Travada Aguardando Notificação
  35. Algumas Dicas
    • Você pode ter ouvido dizer que para melhorar a performance, você deve evitar o uso de sincronização quando escrever e ler dados atômicos. Este aviso está perigosamente errado.
  36. Algumas Dicas
    • Para evitar o risco de DeadLock, nunca ceda o controle de um método ou bloco sincronizado a um cliente.
      • Num método sincronizado, evite invocar métodos desconhecidos, como por exemplo, um método abstrato.
  37. Algumas Dicas
    • Sempre faça o menos possível dentro de um bloco sincronizado.
  38. Algumas Dicas
    • Somente execute o método wait() de dentro de um loop.
      • O recurso que você estava esperando pode não estar disponível novamente.
  39. Algumas Dicas
    • Qualquer programa que confia no scheduler para a sua correta execução é considerável não-portável.
  40. Obrigado! Perguntas?

+ Glaucio ScheibelGlaucio Scheibel, 2 years ago

custom

748 views, 1 favs, 0 embeds more stats

More info about this document

© All Rights Reserved

Go to text version

  • Total Views 748
    • 748 on SlideShare
    • 0 from embeds
  • Comments 1
  • Favorites 1
  • Downloads 16
Most viewed embeds

more

All embeds

less

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate. If needed, use the feedback form to let us know more details.

Cancel
File a copyright complaint
Having problems? Go to our helpdesk?

Categories