Programação para Ambiente Web II: THREADS

Prévia do material em texto

THREADS 
Programação para Ambiente Web II 
Prof. Thiago Meirelles Ventura 
UFMT – IC – 2014/2 
Agenda 
•  Conceitos 
•  Características de processos 
•  Características de threads 
•  Thread x Processo 
•  Utilização de threads 
•  Exemplos 
•  Gerenciamento de threads 
•  Sincronização de threads 
•  Implementação 
•  Exercício 
Conceitos 
•  Processo 
 
Um programa em execução. 
 
 
 
 
 
 
 
Conceitos 
•  Processo 
 
Um programa em execução, 
 
sendo constituído de: 
•  código executável 
•  dados referentes ao código 
•  pilha de execução 
•  valor do contador de 
programa 
•  valor do apontador do 
apontador de pilha 
•  valores dos demais 
registradores do hardware 
•  conjunto de outras 
informações necessárias 
para a execução dos 
programas 
 
Conceitos 
•  Thread 
 
Unidade básica de utilização da CPU. 
 
 
 
 
 
 
 
Conceitos 
•  Thread 
 
Unidade básica de utilização da CPU. 
 
Possui seu próprio contador de programa, sua 
pilha e seus registradores. Porém, compartilham 
todos o mesmo espaço de endereçamento (como 
se fossem uma única entidade). 
 
Também chamado de lightweight process. 
 
Conceitos 
http://www-di.inf.puc-rio.br/~endler/courses/inf1019/transp/cap-02.pdf 
Conceitos 
http://www.alexandrelobao.com/Jogos/artigos/Multithread.asp 
Conceitos 
•  Gerência de processos 
•  É uma das principais funções de um sistema operacional 
•  Possibilita aos programas alocar recursos, compartilhar dados, 
trocar informações e sincronizar suas execuções. 
Conceitos 
•  Gerência de processos 
•  Em sistemas multiprogramáveis os processos são executados 
concorrentemente, compartilhando o uso do processador, memória 
principal e dispositivos de E/S, dentre outros recursos. 
 
Conceitos 
•  Gerência de processos 
•  Nos sistemas com múltiplos processadores não só existe a 
concorrência de processos pelo uso do processador como também 
a possibilidade de execução simultânea de processos nos 
diferentes processadores. 
Conceitos 
•  Estados de um processo 
Características de processos 
Características de processos 
Características de threads 
•  Permite ter múltiplos fluxos de controle. 
•  Todas as threads de um processo compartilham a 
memória e os recursos desse processo. 
•  Pode “ler e escrever” em qualquer local, mesmo na pilha 
de outras threads - o que significa que não há qualquer 
forma de proteção de acesso entre as threads. 
•  Operam de forma semelhante a processos quanto ao seu 
estado. Podem ser pronto, bloqueado, executando e 
terminado. 
•  Podem criar threads filhas. 
Thread x Processo 
 
 
Criar ou terminar uma thread é mais 
rápido que criar ou terminar um 
processo. 
Thread x Processo 
 
 
O chaveamento de duas threads (do 
mesmo processo) gasta menos tempo 
que o chaveamento entre dois 
processos diferentes. 
Thread x Processo 
 
 
As threads de um processo 
compartilham memória e arquivos e 
podem se comunicar sem a 
intermediação (invocação) do núcleo. 
Thread x Processo 
 
 
Aplicações que requerem o 
compartilhamento de buffers (por 
exemplo, produtores e consumidores) 
se beneficiam da utilização de threads. 
Thread x Processo 
 
 
 
Implementação mais fácil. 
Utilização de threads 
•  Permitir a exploração do paralelismo real oferecido por 
máquinas multiprocessadores 
 
•  Aumentar número de atividades executadas por unidade 
de tempo 
•  Aumentar o tempo de resposta, possibilidade de associar 
threads a dispositivos de entrada/saída 
•  Sobrepor operações de cálculo com operações de 
entrada e saída 
Exemplos 
•  Leitura contínua de dados de um dispositivo de entrada 
•  Em alguns casos o programa não pode parar o seu 
processamento para fazer a leitura de um dado. 
•  Uma thread pode ficar responsável apenas para ler os dados 
Exemplos 
•  Editor de texto 
•  Thread para fazer correção ortográfica 
•  Thread para fazer gravação automática 
•  Thread para sugerir palavras 
•  ... 
Exemplos 
•  Programa de chat on-line 
•  Uma thread para cada conversa 
http://tech.gaeatimes.com/ 
Exemplos 
•  Grande quantidade de processamento 
•  Utilizar de paralelismo 
•  Uma thread diferente para cada processamento 
Gerenciamento de threads 
•  Nível do usuário 
•  Nível do núcleo 
•  Gerenciamento misto 
Gerenciamento de threads 
•  Nível do usuário 
Gerenciamento de threads 
•  Nível do usuário - Características 
•  Todo o gerenciamento é feito pela aplicação. 
•  Há uma biblioteca que oferece todo o suporte necessário em modo 
usuário, sem a necessidade de chamadas ao sistema. 
•  O núcleo não conhece a existência de threads. 
Gerenciamento de threads 
•  Nível do usuário - Vantagens 
•  Possibilidade de um SO que não suporta threads, implementar 
aplicações multithreads. 
•  Threads em modo usuário são rápidos e eficientes, por dispensar 
acesso ao núcleo do sistema para a criação, eliminação, 
sincronização e troca de contexto das threads. 
Gerenciamento de threads 
•  Nível do usuário - Desvantagens 
•  Se uma thread é bloqueada, provavelmente o processo todo será 
bloqueado. 
•  Incapacidade de múltiplas threads em um processo serem 
executadas por processadores diferentes simultaneamente. 
Gerenciamento de threads 
•  Nível do núcleo 
Gerenciamento de threads 
•  Nível do núcleo - Características 
•  Implementadas diretamente pelo núcleo do sistema. 
•  O núcleo gerência threads (incluindo criação e escalonamento). 
Gerenciamento de threads 
•  Nível do núcleo - Vantagens 
•  No caso de múltiplos processadores, as threads de um mesmo 
processo podem ser executadas simultaneamente. 
•  Não há problemas com relação a compartilhamento de variáveis, 
tratamento de sinais e chamadas síncronas. 
•  Se uma thread é bloqueada, o núcleo ainda pode executar outra 
thread do mesmo processo. 
 
Gerenciamento de threads 
•  Nível do núcleo - Desvantagem 
•  Dez vezes mais lento que o modo usuário. 
Gerenciamento de threads 
•  Gerenciamento misto 
Gerenciamento de threads 
•  Gerenciamento misto 
•  Tenta combinar as vantagens dos outros dois tipos (usuário e 
núcleo). 
•  Maior flexibilidade. 
•  Ainda tem desvantagens dos outros dois tipos. 
Sincronização de threads 
•  Qual valor será escrito na tela? 
Thread 1 
public void run() { 
 soma = soma + 5; 
} 
Thread 2 
public void run() { 
 soma = soma * 3; 
} 
public static void main(String[] args) { 
 ... 
 static int soma = 1; 
 thread1.start(); 
 thread2.start(); 
 System.out.println("%d", soma); 
} 
Sincronização de threads 
 
 
Quando duas ou mais threads podem simultaneamente 
alterar às mesmas variáveis globais, poderá ser necessário 
sincronizar o acesso a esta variável para evitar problemas. 
Sincronização de threads 
•  A solução para estes casos é garantir a exclusão mútua 
•  Apenas um processo tem autorização para acessar o recurso de 
cada vez. 
•  O trecho do programa onde é feito o acesso ao recurso 
compartilhado é denominado região crítica. 
•  Os mecanismos que implementam a exclusão mútua utilizam um 
protocolo de acesso à região crítica. 
•  Toda vez que um processo for executar sua região crítica, ele é 
obrigado a passar por um controle de entrada e outro de saída. 
Sincronização de threads 
pthread_mutex_lock( &mutex1 ); 
 
 ... 
 
 seção crítica 
 
 ... 
 
pthread_mutex_unlock( &mutex1 ); 
 
Implementação 
•  Java 
•  Java (Android) 
•  C# 
•  C 
•  PHP 
Implementação 
•  Java 
public class RunnableExample{ 
 public static void main(String[] args) { 
 Thread thread1 = new Thread(new RunnableThread(), "thread1"); 
 Thread thread2 = new Thread(new RunnableThread(), "thread2"); 
 RunnableThread thread3 = new RunnableThread("thread3"); 
 
 thread1.start(); 
 thread2.start(); 
 try { 
 Thread.currentThread().sleep(1000); 
 } catch (InterruptedException e) { 
 } 
 
 System.out.println(Thread.currentThread()); 
 } 
} 
Implementação 
•  Java 
class RunnableThread implements Runnable { 
 Thread runner; 
 
 public RunnableThread() { 
 } 
 
 public RunnableThread(String threadName) { 
 runner = new Thread(this, threadName); 
 System.out.println(runner.getName()); 
 runner.start(); 
 } 
 
 public void run() { 
 System.out.println(Thread.currentThread()); 
 } 
} 
Implementação 
•  Java (Android) 
public void onClick(View v) { 
 new Thread(new Runnable() { 
 public void run() { 
 final Bitmap bitmap = loadImageFromNetwork("http://
example.com/image.png"); 
 mImageView.post(new Runnable() { 
 public void run() { 
 mImageView.setImageBitmap(bitmap); 
 } 
 }); 
 } 
 }).start(); 
} 
Implementação 
•  C# 
public class MyClass { 
 public static void Main() { 
 Console.WriteLine(”Antes do início das threads"); 
 
 Thread tid1 = new Thread(new ThreadStart(MyThread.Thread1)); 
 Thread tid2 = new Thread(new ThreadStart(MyThread.Thread2)); 
 
 tid1.Start(); 
 tid2.Start(); 
 } 
} 
Implementação 
•  C# 
using System; 
using System.Threading; 
 
public class MyThread { 
 public static void Thread1() { 
 for (int i = 0; i < 10; i++) { 
 Console.WriteLine("Thread 1: {0}", i); 
 } 
 } 
 
 public static void Thread2() { 
 for (int i = 0; i < 10; i++) { 
 Console.WriteLine("Thread 2: {0}", i); 
 } 
 } 
} 
Implementação 
•  C 
int main (int argc, char *argv[]) { 
 pthread_t thread[5]; 
 int rc; 
 long t; 
 for(t=0; t < 5; t++){ 
 printf(”Em main: criando thread %ld\n", t); 
 rc = pthread_create(&threads[t], NULL, PrintHello, (void *)t); 
 if (rc){ 
 printf("ERRO: %d\n", rc); 
 exit(-1); 
 } 
 } 
 pthread_exit(NULL); 
} 
Implementação 
•  C 
#include <pthread.h> 
#include <stdio.h> 
 
void *PrintHello(void *threadid) { 
 long tid; 
 tid = (long)threadid; 
 printf("Hello World! Thread #%ld!\n", tid); 
 pthread_exit(NULL); 
} 
Implementação 
•  PHP 
require_once( 'Thread.php' ); 
 
if( ! Thread::available() ) { 
 die( 'Threads não são suportadas' ); 
} 
 
// Método que será chamado para a thread 
function processImage( $_image ) { 
 // código para o processamento de imagem 
} 
Implementação 
•  PHP 
$threads = array(); 
$index = 0; 
 
foreach( new DirectoryIterator( ’/images' ) as $item ) { 
 if( $item->isFile() ) { 
 $threads[$index] = new Thread( 'processImage' ); 
 $threads[$index]->start( $item->getPathname() ); 
 ++$index; 
 } 
} 
 
// Espera todas as threads finalizarem 
while( !empty( $threads ) ) { 
 foreach( $threads as $index => $thread ) 
 if( ! $thread->isAlive() ) 
 unset( $threads[$index] ); 
 sleep( 1 ); 
} 
Exercício 
•  Implemente um programa que simule a venda on-line de 
ingressos para um show. 
•  A cada 10 segundos é liberado um lote de 20 ingressos 
•  No total serão liberados 4 lotes 
•  Há 100 pessoas querendo comprar ingressos 
•  Cada pessoa tenta comprar um ingresso de 3 em 3 segundos 
•  Cada pessoa só pode comprar 1 ingresso 
•  Sinalize os momentos que um lote ficou disponível, que um lote se 
esgotou e que uma pessoa comprou um ingresso 
•  Linguagem de programação: livre 
•  Apresentar em: 17/10