• Save
Programação Paralela - Threads
Upcoming SlideShare
Loading in...5
×
 

Programação Paralela - Threads

on

  • 7,173 views

 

Statistics

Views

Total Views
7,173
Views on SlideShare
6,984
Embed Views
189

Actions

Likes
5
Downloads
16
Comments
2

9 Embeds 189

http://www.jornaljava.com 72
http://javadesk.org 46
http://www.slideshare.net 36
http://lossurdojava.blogspot.com 28
http://www.follow2.com 3
http://static.slidesharecdn.com 1
http://www.lossurdojava.blogspot.com 1
http://www.linkedin.com 1
https://www.linkedin.com 1
More...

Accessibility

Categories

Upload Details

Uploaded via as OpenOffice

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Programação Paralela - Threads Programação Paralela - Threads Presentation Transcript

  • Programação Paralela - Threads Glaucio Scheibel - GUJava/SC
  • O que é uma Thread?
    • Java é um computador virtual e Thread é a sua CPU virtual.
    • Num computador virtual podemos ter quantas CPU’s virtuais quisermos.
  • Thread: Outras definições
    • Divisão de um processo. SubProcesso.
    • Linha de execução.
  • 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.
  • 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.
  • 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.
  • Programa sem Threads
  • Programa com Threads
  • Concorrência X Paralelismo Tarefa Tarefa Tempo Tempo
  • 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.
  • 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.
  • Modelos de Thread
    • Cooperativo
    • Preemptivo
  • 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.
  • 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 .
  • 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.
  • 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.
  • 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.
  • Microsoft Windows NT
    • Modo preemptivo para processos e threads.
    • 7 níveis de prioridade.
    • Priority Boosting (acessível via C).
  • 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).
  • 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.
  • Partes de uma Thread Java
  • 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);
        • }
      • }
    • }
  • Criando a CPU de uma Thread
    • public class Teste {
    • public static void main(String[] args) {
    • Contador c = new Contador();
    • Thread t = new Thread(c);
    • }
    • }
  • 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
  • Compartilhamento
    • Diferentes Threads podem compartilhar o mesmo código:
      • Thread t1 = new Thread( c );
      • Thread t2 = new Thread( c );
      • Thread t3 = new Thread( c );
  • Estados da Thread Pronto Rodando Bloqueada
  • 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.
  • 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.
  • 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
  • Preemptivo: Sincronização
    • Modificador synchronized.
      • O próprio objeto é o monitor.
    • synchronized(Object o) {}.
      • Bloco sincronizado especificando qual o objeto monitor.
  • Estados da Thread - Sincronização Pronto Rodando Bloqueada Travada
  • 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.
  • 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.
  • Estados da Thread - Sincronização Pronto Rodando Bloqueada Travada Aguardando Notificação
  • 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.
  • 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.
  • Algumas Dicas
    • Sempre faça o menos possível dentro de um bloco sincronizado.
  • 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.
  • Algumas Dicas
    • Qualquer programa que confia no scheduler para a sua correta execução é considerável não-portável.
  • Obrigado! Perguntas?