Programação Concorrente



Baixar 25.2 Kb.
Encontro22.02.2018
Tamanho25.2 Kb.

Programação Concorrente

Processos


Processo = Programa em execução.

Um processo é constituído basicamente de:

 Código executável;

 Pilha de execução;

 Dados;

 Estado;

 Registradores (PC, ...);

 Prioridade, arquivos abertos, ...

Cada processo tem sua própria CPU virtual.

A CPU física é compartilhada entre os vários processos:

 Multiprogramação/Compartilhamento de tempo

 Pseudoparalelismo

Um escalonador seleciona qual processo deve usar a CPU a cada momento e por quanto tempo.

Mudança de Contexto


A troca de um processo por outro na CPU chama-se mudança de contexto.

Durante uma mudança de contexto:

Estado atual do processo e seus registradores devem ser salvos;
O mapa de memória deve ser salvo;
Um novo processo deve ser escolhido;
O novo processo precisa ser iniciado;
Necessidade de troca de processos (swapping).

A mudança de contexto fornece transparência de concorrência para o usuário, contudo, é uma atividade dispendiosa!


Implementação de Processos


O sistema operacional controla os processos a serem executados por meio do uso de uma Tabela de Processos, a qual contém uma entrada para cada processo.

Cada entrada contém também todas as informações necessárias para a realização de mudanças de contexto:

Contador de Programa
Registradores
Ponteiro de pilha
Estado
Variáveis globais
Arquivos abertos
Processos filhos
Alarmes pendentes
Sinais e tratadores de sinais
Uso de recursos

Com isso, pode-se suspender a execução de um processo e, em um momento mais adiante, reiniciar a sua execução a partir daquele ponto de parada.


Threads


Em uma máquina multiprocessada ou em um cluster de computadores, podemos ter vários processos (inclusive de uma mesma aplicação) rodando ao mesmo tempo (vale salientar que em máquinas monoprocessadas o que ocorre é um pseudoparalelismo).

Entretanto, na prática, precisamos de uma granularidade ainda menor, isto é, precisamos de paralelismo dentro de um mesmo processo.

Esse paralelismo interno ao processo é obtido com o uso de Threads.

Alguns autores usam o termo processo leve (lightweight process) ao invés de thread. Na realidade, uma thread é análoga a um processo tendo em vista que ambos são uma execução sequencial de um conjunto de instruções. Contudo, uma thread é considerada leve pelo fato de rodar dentro do contexto do processo, aproveitando-se do compartilhamento dos recursos alocados para o ambiente do programa.

Portanto, uma thread é um subconjunto das informações pertinentes a um processo e as threads de um mesmo processo compartilham recursos entre si:


Itens por Processo

Itens por Thread

Espaço de endereçamento
Variáveis globais
Arquivos abertos
Processos filhos
Alarmes pendentes
Sinais e tratadores de sinais
Uso de recursos

Contador de Programa
Registradores
Pilha
Estado

Cada thread tem sua própria pilha de execução.



Threads são bem mais fáceis de criar e destruir, o que implica em um ganho de performance considerável.

Implementação de Threads


Há dois tipos de threads: de usuário e de sistema (núcleo).

Threads de usuário:

 O sistema (núcleo) não sabe da existência de threads

 Núcleo gerencia processos monothread

 Cada processo tem sua própria tabela de threads

 Um sistema supervisor, dentro do processo, gerencia os threads

 Salva estado

 Faz escalonamento

 Melhor desempenho

Threads devem se comportar educadamente -> Ceder a vez quando não puderem continuar.



Threads de sistema:

 O núcleo conhece as threads e as gerencia

 Núcleo tem tabela de threads e tabela de processos

 Bloqueio de threads = chamadas ao sistema

 Núcleo escolhe outro thread do mesmo processo ou um thread de outro processo


Programação Multithreaded em Java


Grande parte das aplicações existentes usam o conceito de multitarefa (multithread). Por exemplo, quando estamos usando um navegador WEB (Internet Explorer, Netscape, ...), ao mesmo tempo em que estamos lendo um texto, também podemos estar efetuando o download de arquivos e ouvindo música. Para cada uma dessas atividades, o navegador cria threads que executarão em (pseudo)paralelamente.

Nas próximas seções, estaremos vendo detalhes da implementação de aplicações multitarefa usando a linguagem Java.


Criando uma subclasse de java.lang.Thread e rescrevendo o método run()


A linguagem Java fornece uma classe chamada Thread a partir da qual o programador pode criar suas próprias threads. Para isso, é preciso que o programador estenda essa classe e implemente as devidas customizações, reescrevendo o método run().

public class SimpleThread extends Thread {

public SimpleThread(String str) {

super(str);

}

public void run() {



for (int i = 0; i < 10; i++) {

System.out.println(i + " " + getName());

try {

sleep((long)(Math.random() * 1000));



} catch (InterruptedException e) {}

}

System.out.println("DONE! " + getName());



}

}

O método run() é onde colocamos toda a lógica de execução da thread. Em outras palavras, esse método é o coração da thread. Particularmente no exemplo acima, o método run() da classe SimpleThread contém um laço que é executado dez vezes. Em cada iteração, o método exibe na saída-padrão do sistema o número correspondente àquela iteração e o nome que foi associado à thread. Então, a thread entra em modo de espera durante um intervalo de tempo que vai de 0 a 1 segundo. Quando o laço termina, o método run imprime DONE! seguido do nome da thread.



O programinha a seguir instancia duas threads da classe acima e inicia a execução das mesmas:

public class TwoThreadsDemo {

public static void main (String[] args) {

new SimpleThread("Jamaica").start();

new SimpleThread("Fiji").start();

}

}



Um exemplo de saída durante a execução desse programinha poderia ser:

0 Jamaica

0 Fiji

1 Fiji


1 Jamaica

2 Jamaica

2 Fiji

3 Fiji


3 Jamaica

4 Jamaica

4 Fiji

5 Jamaica



5 Fiji

6 Fiji


6 Jamaica

7 Jamaica

7 Fiji

8 Fiji


9 Fiji

8 Jamaica

DONE! Fiji

9 Jamaica

DONE! Jamaica

Implementando a interface Runnable


Uma outra técnica que pode ser utilizada para implementação de threads na linguagem Java é o uso da interface Runnable.

Vejamos a classe a seguir:

import java.awt.Graphics;

import java.util.*;

import java.text.DateFormat;

import java.applet.Applet;


public class Clock extends Applet implements Runnable {
private Thread clockThread = null;
public void start() {

if (clockThread == null) {

clockThread = new Thread(this, "Clock");

clockThread.start();

}

}
public void run() {



Thread myThread = Thread.currentThread();

while (clockThread == myThread) {

repaint();

try {


Thread.sleep(1000);

} catch (InterruptedException e){

// the VM doesn't want us to sleep anymore,

// so get back to work

}

}

}


public void paint(Graphics g) {

// get the time and convert it to a date

Calendar cal = Calendar.getInstance();

Date date = cal.getTime();

// format it and display it

DateFormat dateFormatter = DateFormat.getTimeInstance();

g.drawString(dateFormatter.format(date), 5, 10);

}
// overrides Applet's stop method, not Thread's

public void stop() {

clockThread = null;



}

}

Como a linguagem Java não permite herança múltipla, então, nesse caso, para se poder construir uma thread é necessário a implementação da interface Runnable.


Compartilhe com seus amigos:


©aneste.org 2020
enviar mensagem

    Página principal
Universidade federal
Prefeitura municipal
santa catarina
universidade federal
terapia intensiva
Excelentíssimo senhor
minas gerais
união acórdãos
Universidade estadual
prefeitura municipal
pregão presencial
reunião ordinária
educaçÃo universidade
público federal
outras providências
ensino superior
ensino fundamental
federal rural
Palavras chave
Colégio pedro
ministério público
senhor doutor
Dispõe sobre
Serviço público
Ministério público
língua portuguesa
Relatório técnico
conselho nacional
técnico científico
Concurso público
educaçÃo física
pregão eletrônico
consentimento informado
recursos humanos
ensino médio
concurso público
Curriculum vitae
Atividade física
sujeito passivo
ciências biológicas
científico período
Sociedade brasileira
desenvolvimento rural
catarina centro
física adaptada
Conselho nacional
espírito santo
direitos humanos
Memorial descritivo
conselho municipal
campina grande