Please enable JavaScript.

Coggle requires JavaScript to display documents.

Threads - Coggle Diagram

- - - - Um sistema é paralelo quando pode executar mais de uma tarefa simultaneamente
    - - Em sistemas concorrentes, várias tarefas progridem simultaneamente, com a CPU alternando entre processos, criando a ilusão de execução simultânea em tempo humano.
  - - - Identificação de tarefas e divisão das atividades
        
        O ideal é que as tarefas sejam independentes umas das outras
      - Equilíbrio
        
        É preciso dosar as atividades para que apresentem esforço computacional parecido.
      - Divisão de dados
        
        Dados acessados e manipulados devem ser divididos para a execução em núcleos separados
      - Dependência de dados
        
        Examinar dados é essencial para identificar dependências entre duas ou mais tarefas.
        
        Sincronização é necessária quando uma tarefa depende dos dados de outra.
      - Teste e depuração
        
        A execução de programas paralelos envolve diferentes caminhos de execução, o que torna o teste e a depuração mais desafiadores.
    - - Paralelismo de Dados (Data Parallelism)
        
        Distribui subconjuntos de um mesmo dado para múltiplos núcleos e executa a mesma operação em cada um deles
      - Paralelismo de Tarefas (Task Parallelism)
        
        Distribuem-se tarefas a múltiplos núcleos.
        
        Essas tarefas são diferentes e podem operar sobre um mesmo conjunto de dados.
- - - - Código e estruturas de dados estão em modo usuário.
    - - Código e estruturas de dados no espaço de kernel
  - - - Assim que o pai cria uma thread-filho, o pai retoma sua execução para que ele e seu filho sejam executados concorrentemente
      - Threads executam independentemente, e a thread-pai não necessita saber quando o thread-filho terminou.
      - Já que os threads são independentes, normalmente há pouco compartilhamento de dados entre eles
      - A criação assíncrona de threads é uma estratégia comum em servidores multithreaded.
    - - No modelo fork-join, o thread-pai cria filhos e aguarda que todos eles terminem antes de retomar sua execução.
      - À medida que cada thread conclua seu trabalho, ele é encerrado e reencontra o seu pai.
      - Somente após todos os filhos terem retornado é que o pai pode retomar a execução
      - A criação síncrona de threads geralmente envolve um significativo compartilhamento de dados, como quando o thread-pai combina os resultados calculados por seus filhos.
  - - - É uma especificação, com implementações disponíveis para Linux, Mac OS X, Windows, etc.
    - - Disponível em C através do cabeçalho windows.h
    - - A API do Java fornece um rico conjunto de aspectos de criação e gerenciamento de threads
      - Existem duas formas de criação de threads em Java
        
        Herdando da classe Thread e redefinindo o método run()
        
        Implementando a interface Runnable (mais usada).
- - - - ligeiramente mais rápido atender uma solicitação com um thread existente do que criar uma nova thread
      - Limita (controla) o número de threads existentes a qualquer momento.
  - - - A alocação de recursos ou atualizações de dados em andamento pode tornar essa abordagem problemática, com potencial falta de liberação adequada dos recursos ao sistema operacional.
  - - - Sinal é gerado por evento em particular
      - Sinal é entregue a um processo
      - Sinal é tratado
    - - Entregar o sinal ao thread ao qual o sinal se aplica
      - Entregar o sinal a cada thread no processo
      - Entregar o sinal a certos threads no processo
      - Atribuir uma área específica para receber todos os sinais para o processo
  - - - Essa implementação utiliza uma estrutura de dados intermediária chamada Processo Leve (LWP).
        
        Cada LWP é como um processador virtual.
        
        Cada LWP é ligado a uma thread de kernel.
        
        SO escalona threads de kernel
      - Ativações do escalonador oferece upcalls
        
        um mecanismo de comunicação do kernel para a biblioteca de threads.
      - Essa comunicação permite que uma aplicação mantenha o número correto de threads do kernel
- - - - Muitos threads em nível de usuário mapeados para único thread do kernel.
      - Modelo eficiente, mas o processo inteiro fica bloqueado se uma thread fizer uma chamada de sistema bloqueante.
      - Imprópria para sistemas multiprocessadores, pois apenas uma thread pode acessar o kernel por vez.
    - - Cada thread em nível de usuário é mapeado para thread do kernel
      - Maior concorrência e uso de Memoria
      - Única desvantagem
        
        É custoso criar muitas threads de kernel, podendo prejudicar o desempenho da aplicação
      - Usado pelo Linux e Windows
    - - Permite mapear muitos threads em nível de usuário para muitos threads do kernel.
      - Permite que o sistema operacional crie um número suficiente de threads do kernel.
- - - - Threads separadas para cada aba, imagens e texto, transmissão de dados pela rede
    - - Threads podem lidar com gráficos, entradas do usuário, verificação ortográfica em segundo plano, e mais.