Threads

Threads
Um thread uma sequncia de instrues que vo ser executadas num programa. No ambiente UNIX, os threads encontram-se
dentro de um processo, utilizando os recursos desse processo. Um processo pode ter vrios threads.
Pode-se dizer que um thread um procedimento que executado dentro de um processo de uma forma independente. Para melhor
perceber a estrutura de um thread til entender o relacionamento entre um processo e um thread. Um processo criado pelo
sistema operativo e podem conter informaes relacionadas com os recursos do programa e o estado de execuo do programa:
Process ID, process group ID, group ID 1.
Ambiente 2.
Directoria de trabalho 3.
Instrues do programa 4.
Registos 5.
Pilha (Stack) 6.
Espao de endereamento comum, dados e memria 7.
Descritores de ficheiros 8.
Comunicao entre processos (pipes, semforos, memria partilhada, filas de mensagens) 9.
Os threads utilizam os recursos de um processo, sendo tambm capazes de ser escalonados pelo sistema operativo e serem
executados como entidades independentes dentro de um processo.
Um thread pode conter um controlo de fluxo independente e ser escalonvel, porque mantm o seu prprio:
Pilha 1.
Propriedades de escalonamento 2.
Dados especficos do thread 3.
Um processo pode ter vrios threads, partilhando cada um os recursos do processo e so executados no mesmo espao de
endereamento. Com vrios threads, temos em qualquer instante vrios pontos de execuo.
Como os threads partilham os recursos de um processo:
as alteraes feitas por um thread num recurso partilhado (ex: fechar um ficheiro) sero "vistaa" pelos outros threads. 1.
Dois apontadores com o mesmo valor, apontam para os mesmos dados. 2.
Threads http://www.dei.isep.ipp.pt/~orlando/so2/threads.htm
1 de 15 2/9/2013 11:16
possvel ler e escrever nas mesmas posies de memria, sendo por isso necessria uma sincronizao explcita que
tem de ser feita pelo programador.
3.
Todos os threads esto no mesmo nvel hierrquico. Um thread no mantm uma lista dos threads criados nem tem conhecimento
do thread que o criou.
Vantagens:
ganhos nas performances dos programas; 1.
quando comparados com a criao e gesto de um processo, os threads podem ser criados com muito menos sobrecarga
para o sistema operativo. A gesto dos threads necessita de menos recursos que a gesto dos processos;
2.
todos os threads num processo partilham o mesmo espao de endereamento. A comunicao entre threads mais
eficiente e na maior parte das situaes mais fcil do que a comunicao entre processos;
3.
As aplicaes com threads so mais eficientes e tm mais vantagens prticas: 4.
- Sobrecarregar o CPU com operaes de entrada/sada de dados. Por exemplo, um programa tem situaes onde
necessita de efectuar operaes de entrada/sada de dados muito demoradas. Enquanto um thread espera que a operao de
entrada/sada de dados termine, o CPU pode ser utilizado para efectuar outras operaes atravs de vrios threads;
- Tratamento de eventos assncronos. Por exemplo, um servidor web pode transmitir dados de pedidos anteriores e ao
mesmo tempo fazer a gesto dos novos pedidos.

Gesto de Threads
Inicialmente, o processo apenas tem um thread (main()). Todos os outros threads so criados explicitamente pelo programador.

Criao de threads
pthread_create(thread, attr, funo, argumento)
Esta funo cria um novo thread e torna-o executvel. Os threads podem criar outros threads. 1.
A funo retorna a identificao do thread atravs do parmetro thread. Esta identificao pode ser utilizada para
efectuar vrias operaes nesse thread.
2.
attr usado para definir as propriedades do thread. Podem-se especificar os atributos ou o NULL para os valores por
defeito.
3.
funo o nome da funo que vai ser executada pelo thread. 4.
Pode-se passar um argumento para a funo atravs de argumento. Deve-se fazer sempre o cast para o apontador de um
void. Para passar mais do que um argumento, pode-se utilizar uma estrutura que contenha todos os argumentos e depois
passar um apontador para essa estrutura.
5.

Terminar a execuo de um thread
Existem vrias maneiras de um thread terminar:
O thread retorna da sua funo inicial (a funo main para o thread inicial). 1.
O thread executa a funo pthread_exit 2.
O thread foi cancelado por outro thread atravs da funo pthread_cancel 3.
O thread recebeu um sinal que fez com que terminasse; 4.
Todo o processo foi terminado devido utilizao da funo exec (que substitui a imagem do processo) ou atravs da
funo exit (que termina um processo!)
5.
2 de 15 2/9/2013 11:16
pthread_exit(estado)
Esta funo termina explicitamente um thread, Utiliza-se esta funo depois de um thread j ter completado o seu
trabalho.
1.
Se o main() termina antes dos threads que foram criados, e termina atravs da utilizao de pthread_exit(), os
outros threads continuaro a ser executados, caso contrrio terminam automaticamente quando main() termina.
2.

Exemplo 1: Este exemplo cria trs threads, cada um imprimindo a mensagem "Sistemas Operativos II " e o nmero do thread,
terminando de seguida com a funo pthread_exit()
/* Para compilar fazer: gcc -o fich fich.c -lpthread */

#include <pthread.h>
#include <stdio.h>

void *escreve(void *numero)
{
int *n =(int *) numero;
printf("Sistemas Operativos II thread n. = %d\n",*n);
pthread_exit(NULL);
}

void main()
{
pthread_t threads[3];
int s,i;
for (i=0; i<3; i++)
{
printf("A criar o thread n. %d\n",i);
s=pthread_create(&threads[i], NULL, escreve, (void *) &i);
if (s)
{
perror("Erro ao criar o thread");
exit(-1);
}
3 de 15 2/9/2013 11:16
}
pthread_exit(NULL); /* se a funo main no terminar com a funo phtread_exit o
ultimo
thread no chega a terminar a sua execuo */
}
Nota: Neste exemplo pode acontecer que aparea o mesmo nmero repetido (ex: 233).
Isto deve-se ao facto de quando o thread mostra o valor da varivel i, este j foi
alterado. Para evitar esta situao deve-se utilizar um array de inteiros, sendo cada
posio utilizada apenas por um thread.

Funes para identificao de threads
pthread_self()
retorna o identificador desse thread. 1.
pthread_equal()
compara dois identificadores de threads. Se so diferentes retorna 0, seno retorna um valor diferente de 0. 1.

Sincronizao de threads
pthread_join(thread_id, estado)
bloqueia o thread que chamou esta funo at que o thread com o identificador thread_id termine. 1.
tambm possvel obter o estado do thread que terminou, se esse terminou com a funo pthread_exit(estado). 2.
Tem um conportamento semelante funo wait utilizadanos processos. 3.
Quando se cria um thread, um dos atributos que pode ser alterado se outros threads podem ou no chamar a funo
pthread_join sobre ele. Para isso so possveis dois valores:
Detached no pode ser feito o join (PTHREAD_CREATE_DETACHED); 1.
Undetached pode ser feito o join (PTHREAD_CREATE_JOINABLE) 2.

Funes para manipulao de atributos
pthread_attr_init(attr)
pthread_attr_setdetachstate(attr, detachstate)
pthread_attr_destroy(attr)
pthread_detach(tread_id, estado)
Para utilizar so necessrios os seguintes passos:
Declarar a varivel com o tipo de dados pthread_attr_t ; 1.
Inicializar a varivel com a funo pthread_attr_init 2.
Definir o estado do atributo com a funo pthread_attr_setdetachstate; 3.
Libertar os recursos utilizados por essa varivel com a funo pthread_attr_destroy 4.

4 de 15 2/9/2013 11:16
Exemplo 2: Este exemplo espera que todos os threads terminem atravs da utilizao da funo pthread_join.

#include <stdio.h>
void *ocupa_tempo(void *null)
{
int i,j;
for (i=0;i<50000;i++)
j+=i;
pthread_exit(NULL);
}

void main()
{
pthread_attr_t attr;
int s,i,estado;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
for(i=0; i<5; i++)
{
printf("A criar o thread %d\n",i);
s=pthread_create(&threads[i], &attr,ocupa_tempo, NULL );
if (s)
{
perror("Erro ao criar o thread");
exit(-1);
}
}
pthread_attr_destroy(&attr);
for(i=0; i<5; i++)
{
s=pthread_join(threads[i], (void **) &estado);
5 de 15 2/9/2013 11:16
if (s)
{
perror("Erro no join");
exit(-1);
}
printf("O thread %d terminou com o estado %d\n",i,estado);
}
pthread_exit(NULL);
}

Variveis de excluso mtua

As variveis de excluso mtua (mutex) so uma das formas de obter sincronizao entre threads. Actuam como um semforo
com um nico recurso, fechando e protegendo o acesso a um recurso partilhado. Num dado instante apenas um thread consegue
fechar uma varivel de excluso mtua. Estas variveis podem ser usadas para evitar race conditions. Segue-se um exemplo
de uma race condition numa transaco bancria assumindo que o balano inicial 10000.00:

Instante Thread 1 Thread 2 Balano
1
A balano
10000.00
2
B balano
10000.00
3
balano B 5000.00
5000.00
4
balano A + 6000.00
16000.00

Neste exemplo deveria ser usada uma varivel mutex para fechar o balano enquanto utilizado por cada thread, de modo a
evitar situaes de incoerncia (neste caso o resultado correcto 11000$00 !).

Funes para a criao/destruio de variveis mutex:

pthread_mutex_init(mutex,attr)

1. cria e inicializa uma varivel mutex, definindo os seus atributos de acordo com attr;
2. As variveis mutex devem ser do tipo pthread_mutex_t;
3. attr utilizado para definir as propriedades da varivel mutex, e deve ser do tipo pthread_mutexattr_t se for
usada (para utilizar os valores por defeito, pode-se usar NULL em substituio de attr)

pthread_mutex_destroy(mutex)

4. destri a varivel mutex.

pthread_mutexattr_init(attr)

1. inicializa attr

pthread_mutexattr_destroy(attr)

2. remove attr

Funes para a abrir/fechar varveis mutex:

pthread_mutex_lock(mutex)
6 de 15 2/9/2013 11:16

3. fecha a varivel mutex. Se j estiver fechada a funo bloqueia at que seja possvel fechar.

pthread_mutex_trylock(mutex)

4. tenta fechar a varivel mutex. Se j estiver fechada esta funo no bloqueia e devolve um valor de erro
(EBUSY).

pthread_mutex_unlock(mutex)

5. abre uma varivel mutex. Esta funo dar erro se a varivel mutex j estiver aberta ou se tentar abrir uma
varivel mutex que foi fechada por outro thread.

Exemplo 3: Este exemplo utiliza variveis de excluso mtua para garantir a coerncia dos dados.
#include <stdio.h>
/* definio das variveis globais */
int balanco=10000;
pthread_mutex_t mutex_balanco;
void *deposita(void *valor)
{
int *a= (int *) valor;
/*fecha a varivel mutex_balanco . Se j estiver fechada espera at
que seja possvel fechar*/
pthread_mutex_lock(&mutex_balanco);
balanco += *a;
/* abre a varivel mutex_balanco */
pthread_mutex_unlock(&mutex_balanco);
pthread_exit(NULL);

}
void *levanta(void *valor)
{
int *b= (int *) valor;
/*fecha a varivel mutex_balanco . Se j estiver fechada espera at
que seja possvel fechar*/
pthread_mutex_lock(&mutex_balanco);
7 de 15 2/9/2013 11:16
balanco -= *b;
/* abre a varivel mutex_balanco */
pthread_mutex_unlock(&mutex_balanco);
pthread_exit(NULL);

}

void main()
{
int i,s,estado,depositar=6000,levantar=5000;
/* inicializa a varivel mutex_balanco utilizando os valores por defeito */
pthread_mutex_init(&mutex_balanco, NULL);
pthread_create(&threads[0],NULL,deposita,(void *)&depositar);
pthread_create(&threads[1],NULL,levanta,(void *)&levantar);
for(i=0; i<2; i++)
{
if (s)
{
exit(-1);
}
}
printf("O balano = %d\n",balanco);
pthread_mutex_destroy(&mutex_balanco);
pthread_exit(NULL);
}

Variveis de Condio

As variveis de condio possibilitam outro modo de sincronizao de threads. Enquanto as variveis de excluso mtua
implementam a sincronizao atravs do controlo do acesso aos dados, as variveis de condio permitem a sincronizao de
trheads atravs do valor desses dados. Sem a utilizao destas variveis, os threads tm que estar sempre a verificar se uma
dada varivel tem um valor especfico, ocupando assim tempo de processamento, pois os threads esto constantemente ocupados
com esta actividade. Uma varivel de condio obtm os mesmos resultados sem a necessidade de estar sempre a verificar o
8 de 15 2/9/2013 11:16
valor.
Nota: Uma varivel de condio sempre usada em conjunto com o fecho de uma varivel de excluso mtua.
Funes para a criao/destruio de variveis de condio:

pthread_cond_init(varivel_de_condio,attr)

6. cria e inicializa uma varivel de condio, definindo os seus atributos de acordo com attr;
7. As variveis de condio devem ser do tipo pthread_cond_t;
8. attr utilizado para definir as propriedades da varivel de condio, e deve ser do tipo pthread_mutexattr_t se
for usada (para utilizar os valores por defeito, pode-se usar NULL em substituio de attr)

pthread_cond_destroy(varivel_de_condio)

9. destri a varivel de condio.

pthread_condattr_init(attr)

10. inicializa attr

pthread_condattr_destroy(attr)

11. remove attr

Funes para a utilizao das varveis de condio:

pthread_cond_wait(varivel_de_condio,mutex)

12. bloqueia o thread at que a varivel de condio seja sinalizada. Esta funo deve ser chamada quando a
varivel de excluso mtua se encontra fechada. Esta funo abre automaticamente a varivel mutex de modo a
ser utilizada por outros threads, adormecendo de seguida o thread.
13. Quando chega o sinal, fecha a varivel mutex.

pthread_cond_signal(varivel_de_condio)

14. utilizada para sinalizar (ou acordar) um thread que est espera numa varivel de condio. Deve ser
chamada quando a varivel de excluso mtua se encontra fechada e deve ser aberta a varivel de excluso
mtua para permitir que a funo pthread_cond_wait do outro thread prossiga.

pthread_cond_broadcast(varivel_de_condio)

15. Deve ser utilizada em substituio da funo pthread_cond_signal, quando temos mais que um thread espera.

Exemplo 4: Este exemplo demonstra a utilizao de variveis de condio. So utilizados dois threads para incrementar a
varivel contador

#include <stdio.h>
/* definio das variveis globais */
int contador=0;
pthread_cond_t condicao_contador;
9 de 15 2/9/2013 11:16
pthread_mutex_t mutex_contador;

void *incrementa(void *valor)
{
int i,j;
for(i=0;i<50;i++)
{
pthread_mutex_lock(&mutex_contador);
contador++;
printf(O valor do contador e %d\n,contador);

if (contador == 10)
{
pthread_cond_signal(&condicao_contador);
printf(O valor do contador e 10\n);
}
pthread_mutex_unlock(&mutex_contador);

for(j=0;j<2000;j++) ;
}
pthread_exit(NULL);

}
void *espera(void *valor)
{
printf(O thread est espera que o valor do contador seja 10\n);

/* Fecha a varivel mutex e espera pelo sinal. Nota: a funo
pthread_cond_wait abre automaticamente a varivel mutex para que possa ser usada
por outros threads enquanto espera. Tambm necessrio salientar que se o valor de
contador j for 10, o ciclo no feito, evitando assim uma situao em que o thread
ficaria eternamente espera de um sinal */
pthread_mutex_lock(&mutex_contador);
while (contador < 10)
10 de 15 2/9/2013 11:16
{
pthread_cond_wait(&condicao_contador,&mutex_contador);
/* quando esta funo receber o sinal, fecha a varivel mutex */
printf(O thread recebeu o sinal\n);

}

printf(O contador tem o valor 10\n);
pthread_mutex_unlock(&mutex_contador)
pthread_exit(NULL);

}

void main()
{
int i,s,estado;
/* inicializa a varivel mutex_balanco utilizando os valores por defeito */
pthread_mutex_init(&mutex_contador, NULL);
pthread_cond_init(&condicao_contador,NULL);
pthread_create(&threads[0],NULL,incrementa,NULL);
pthread_create(&threads[1],NULL,incrementa,NULL);
pthread_create(&threads[2],NULL,espera,NULL);

for(i=0; i<3; i++)
{
if (s)
{
exit(-1);
}
}
11 de 15 2/9/2013 11:16
pthread_mutex_destroy(&mutex_contador);
pthread_cond_destroy(&condicao_contador);
pthread_exit(NULL);
}

Exerccios
1- Considere que tem definido na funo main duas strings em que a primeira tem o seu primeiro nome e
a segunda o ltimo. Faa uma funo que receba como parmetros uma string e escreva essa string no
monitor. Implemente um programa em que cada string apresentada por um thread diferente.

2- Considere que tem um array com cinco posies, sendo cada posio constituda pelo nmero, nome e
morada. Faa uma funo que recebe como parmetros uma estrutura desse tipo e imprima o contedo
dessa estrutura. Implemente um programa que crie 5 threads, "passando" como argumentos uma estrutura
desse array (Ex: 0 primeiro thread fica com a primeira posio do array, etc.)

3- Tendo um array de inteiros com 1200 posies, pretende-se calcular resultado[i] = dados[i]*4 + 20.
Crie dois threads :
o primeiro thread calcula as primeiras 400 posies;
o segundo as seguintes 400;
o resto calculado na funo main
Depois dos clculos terminarem, devem ser apresentados os valores no monitor (pode ser
feito na funo main).

4- Dado um array de inteiros com mil posies, crie 5 threads:
Dado um nmero, procurar esse nmero no array.
Cada thread, procura 200 posies.
O thread que encontrar o nmero, deve imprimir a posio do array onde se encontra. Tambm
deve "retornar" como valor de sada o nmero do thread (1, 2, 3, 4, 5).
Os threads que no encontrarem o nmero devem "retornar" como valor de sada o valor 0.
A funo main tem de esperar que todos os threads terminem e imprimir o nmero do thread onde
esse nmero foi encontrado (1, 2, 3, 4, 5).
Nota: O array no tem nmeros repetidos.

5- Para verificar se os montantes depositados pelos seus clientes continuam os mesmos depois de efectuar
alteraes base de dados, pretende-se que calcule a soma total de todos os saldos dos clientes de um
sistema bancrio. Assuma que esses valores esto num array de 1000 posies e os clculos devem ser
feitos por 5 threads. Cada thread faz a soma de 200 posies somando depois esse valor ao saldo total que
deve ser apresentado na funo main.
Nota: tenha em ateno a coerncia dos dados.

6- Uma empresa de estatstica pretende obter quantas vezes cada nmero foi sorteado no totoloto. Para
isso dispe de uma base de dados com 10000 chaves. Utilize dez threads para calcular quantas vezes cada
nmero foi sorteado. O thread principal deve depois imprimir os resultados.

Nota: tenha em ateno que em cada instante apenas um thread deve incrementar o contador de um
determinado nmero (ex: se dois threads encontraram o nmero 5, apenas um deles dever
incrementar o contador relacionado com o nmero 5, estando o outro espera)

Sugesto: Utilize um array de variveis de excluso mtua para garantir a coerncia dos dados.
12 de 15 2/9/2013 11:16

7- Uma empresa pretende simular atravs da utilizao de threads o funcionamento das seguintes viagens
: cidadeA-cidadeD e cidadeC-cidadeA.

Para a simulao tenha em ateno os seguintes aspectos:

- Em cada instante, apenas um comboio pode usar uma das linhas (cidadeA-cidadeB, cidadeB-
cidadeC, cidadeB-cidadeD);

- Quando um comboio ocupa uma linha, deve apresentar no monitor o nmero do comboio, a
sua origem/destino e a linha onde se encontra;

- Quando um comboio termina a viagem deve apresentar no monitor a hora de partida e a hora
de chegada. Para isso, considere que j existe a funo hora() que devolve uma string com a
hora actual (hh:mm:ss);

Considere que se pretendem simular 10 comboios a efectuar a viagem cidadeA-cidadeD e 7 a fazer a
viagem cidadeC-cidadeA.

Para cada comboio, utilize um thread para simular a viagem.

8- Considere um sistema de gesto de stocks armazenado num array com 1000 posies (cada uma tem o
cdigo do produto, o preo de custo, o preo de venda, quantidade em stock). Utilize dois threads (cada
um responsvel por 500 posies) para armazenar num outro array o cdigo e preo dos produtos com
valor superior a 5 euros). Use outro thread para escrever as primeiras 10 posies desse array (esse thread
deve esperar que estejam ocupadas as primeiras dez posies do array).

9- Faa um programa que crie 5 threads. Cada thread responsvel por calcular 200 posies do array
resultado (resultado[i] = dados[i]*2+10). Os threads devem imprimir os resultados segundo a ordem do
array.

10 - Um jornal desportivo encomendou sua empresa uma sondagem para aferir a popularidade dos
jogadores da seleco nacional. Foram efectuadas 10000 entrevistas, em que cada entrevistado escolhia o
seu jogador preferido (atravs do nmero : 1 a 23), sendo esse resultado armazenado no array
FAVORITO. Voc foi encarregado de fazer um programa com os seguintes requisitos:
- crie 10 threads para processar os dados, isto , cada thread responsvel por processar 1000
posies;
13 de 15 2/9/2013 11:16

- Crie 23 threads para apresentar o resultado relativo a cada jogador sempre que este tenha mais 10
votos (ex: apresenta o resultado quando o jogador tem 10, 20, 30, etc.);

- Depois das 10 threads terminarem o processamento, deve ser apresentado o resultado total de
cada jogador (nome e votao) na thread principal, terminando o processo.
Nota 1: tenha em ateno que a utilizao de apenas uma varivel de condio e uma varivel de excluso
mtua produz resultados pouco eficientes!
Nota 2: Os nomes dos jogadores encontram-se no array NOMES.

11 - A brigada de trnsito instalou 100 postos de controlo de velocidade em todo o pas. Com o objectivo
de aumentar a eficcia nesse controlo, pretende desenvolver um sistema que verifique em simultneo os
100 locais. Num determinado local, cada medio efectuada por uma funo que obtm a matrcula e a
velocidade de um automvel. Se a velocidade for superior a 90 km/h, deve armazenar esses dados no
array INFRACOES. Defina tambm uma thread, que sempre que exista um infractor em qualquer dos
locais, passe a respectiva multa.

Os nomes dos 100 locais esto armazenados no array LOCAIS.

Considere que j existem definidas as seguintes funes:

- obtem_velocidade(dados *registo, char *local) obtm a velocidade e a matrcula de um
automvel no local local, colocando esse resultado na varivel registo
- multa(dados registo) emite uma multa para o proprietrio do automvel.

typedef struct {
int velocidade;
char matricula[20];
char local[50];
} dados;

Nota: Tenha em ateno que cada posto de controlo est constantemente a efectuar medies de
velocidade.

Utilize as primitivas de threads para resolver o problema.

12- Uma empresa dispe de quatro funes de clculo avanado para desenvolver um estudo relativo aos
seus produtos. Para cada produto necessita de usar as quatro funes de uma modo encadeado, isto ,
primeiro executa a funo int f1(int codigo), depois executa a funo int f2(int res), em que res o
resultado da execuo da funo f1, depois executa a funo int f3(int res1), em que res1 o resultado
da funo f2, depois executa a funo int f4(int res2), em que res2 o resultado da funo f3, depois
executa a funo int f3(int res3), em que res3 o resultado da funo f4, depois executa a funo int
f2(int res4), em que res4 o resultado da funo f3, depois executa a funo int f1(int res5), em que
res5 o resultado da funo f2 e por fim armazena o resultado da execuo da funo f1 no array
DADOS.
14 de 15 2/9/2013 11:16
Considere que existem 10 produtos e os seus cdigos esto armazenados no array DADOS, em que cada
posio do seguinte tipo:

typedef struct {
int cdigo;
int resultado;
}

Para resolver o problema deve criar 4 threads, em que cada uma das threads ser responsvel por usar
cada uma das quatro funes.

Nota: tenha em ateno que a segunda thread s chama a funo f2, quando for informada que j o
pode fazer. O mesmo se passa para as restantes threads. A primeira thread s inicia o clculo de um novo
produto quando a quarta thread a informar

Utilize variveis de condio e excluso mtua para resolver o problema.

Sugesto: utilize mais de uma varivel de condio.

Implemente o programa.

15 de 15 2/9/2013 11:16

Threads

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Threads

Enviado por

Direitos autorais:

Formatos disponíveis

Threads

Você também pode gostar