Threads

THREADS
EXERCÍCIO 1
CREATE.C
#include <pthread.h> // Incluir pthread funções e estruturas de dados

#include <stdio.h> // Rotinas padrão de ENTRADA/SAÍDA
#include <stdlib.h>
#include <unistd.h>
#define NUM_THREAD 16 // Define um número máximo de 12 Threads
void *threadBody (void *id) // Nova função a ser executada pela thread.
{
long tid = (long) id ;
printf ("t%02ld: Olá!\n", tid) ; // formata e exibe

sleep (3) ;
printf ("t%02ld: Tchau!\n", tid) ;
pthread_exit (NULL) ; //* A chamada desta funçāo provoca a terminaçāo da thread e a

*// liberação dos recursos que esta thread está consumindo:*/
}
int main (int argc, char *argv[])

{
pthread_t thread [NUM_THREADS] ;
long i, status ;
for (i=0; i<NUM_THREADS; i++)

{
printf ("Main: criando thread %02ld\n", i) ;
status = pthread_create (&thread[i], NULL, threadBody, (void *) i) ;
if (status)
{
perror ("pthread_create") ;
exit (1) ;
}
}
pthread_exit (NULL) ;
}
EXERCÍCIO 2

void *threadBody (void *id) // Nova função a ser executada pela thread.
pthread_exit (NULL): A chamada desta funçāo provoca a terminaçāo da thread e a

liberação dos recursos que esta thread está consumindo.
pthread_create: Main thread cria uma thread filho. A função pthread_create() possui
quatro argumentos. O primeiro é usado para guardar a informação sobre a thread criada.
O segundo especifica algumas propriedades da thread a criar, o valor NULL foi utilizado
por default. O Terceiro argumento é a função que a nova thread irá executar e o último
argumento é representa argumentos a esta função.
A função Main cria as threadS conforme a figura de execução do código create.c.
2. A ordem de criação , ativação e encerramento não é a mesma. Segundo o código as

thread’s são criadas, ativadas e encerradas em ordens diferentes, pois existe um espaço
de tempo entre a criação de cada thread, até o número máximo de 20 thread’s
3.
EXERCÍCIO 2
JOIN.C

#include <stdlib.h>
#include <unistd.h>
A Função phtread_join() suspende a execução da thread chamadora até que a thread

especificada no argumento acabe. A thread especificada deve ser do processo corrente e
não pode ser detached.
tid: é a identificação da thread.
status: ponteiro para um objeto que recebe o valor retornado pela thread acordada
Para alterar-mos os atributos de uma thread, a variável do atributo é inicializara

previamente com serviço ptread_attr_init() e posteriormente é modificada através da
chamada de serviços específicos , no código join.c a função pthread_attr_destroy (&attr)
realiza a liberação dos recursos utilizados por uma variável .
Criação de threads:
pthread_create(thread, attire, função, argumento)
ATTR: É utilizado para definição as propriedades do thread. Podem-se especificar os

atributos ou o NULL para os valores por defeito. Esta função cria um novo thread e torna-
o executável. Os threads podem criar outros threads. A função retorna a identificação do
thread através do parâmetro thread. Esta identificação pode ser utilizada para efectuar
várias operações nesse thread. função é o nome da função que vai ser executada pelo
thread. Pode-se passar um argumento para a função através 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.
Terminar um thread
pthread_exit(estado): Esta função termina explicitamente um thread, Utiliza-se esta

função depois de um thread já ter completado o seu trabalho. Se o main() termina antes
dos threads que foram criados, e termina através da utilização de pthread_exit(), os outros
threads continuarão a ser executados, caso contrário terminam automaticamente quando
main() termina.
EXERCÍCIO 3
PRINTX.C
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define NUM_THREADS 16 // Define um máximo de 16 thread
int x = 0 ;
void *threadBody (void *id)

{
long tid = (long) id ;
x++ ;
printf ("t%02ld: Olá! (x=%02d)\n", tid, x) ;
sleep (3) ;
x++ ;
printf ("t%02ld: Tchau! (x=%02d)\n", tid, x) ;
}
int main (int argc, char *argv[])

{
pthread_t thread [NUM_THREADS] ;
long i, status ;
for (i=0; i<NUM_THREADS; i++)

{
printf ("Main: criando thread %02ld\n", i) ;
status = pthread_create (&thread[i], NULL, threadBody, (void *) i) ;
if (status)
{
perror ("pthread_create") ;
exit (1) ;
}
}
}
Neste programa são criadas as thread 00 , 01, 02 , a cada uma delas associam-se valores
a variável x . Primeira thread t00: Olá (x=01), segunda thread t01: Olá (x=02); a seguir é
criada a terceira thread , atribuímos a thread dois o valor da variável (x=03), a thread t03:
Olá (x=4)
SAÍDA DO PROGRAMA:
MacBook-Air-de-Avilah-2:~ avilahflavio$ ./printx

Main: criando thread 00
t00: Olá! (x=01)
t01: Olá! (x=02)
t02: Olá! (x=03)
t03: Olá! (x=04)
t04: Olá! (x=05)
t05: Olá! (x=06)
t06: Olá! (x=07)
t07: Olá! (x=08)
t08: Olá! (x=09)
t09: Olá! (x=10)
t10: Olá! (x=11)
t11: Olá! (x=12)
t12: Olá! (x=13)
t13: Olá! (x=14)
t14: Olá! (x=15)
t15: Olá! (x=16)
t00: Tchau! (x=18)
t01: Tchau! (x=17)
t02: Tchau! (x=19)
t03: Tchau! (x=19)
t04: Tchau! (x=20)
t05: Tchau! (x=21)
t06: Tchau! (x=22)
t07: Tchau! (x=23)
t08: Tchau! (x=24)
t09: Tchau! (x=25)
t10: Tchau! (x=26)
t11: Tchau! (x=27)
t12: Tchau! (x=28)
t14: Tchau! (x=29)
t13: Tchau! (x=29)
t15: Tchau! (x=30)
2. A chamada de sistema fork() cria uma réplica do processo solicitante, assim todo o
espaço da memória deste processo é replicado; esta chamada é invocada por um
processo (pai), entretanto haverá dois processos que receberão seu retorno ( processo
pai que invocou, e o processo filho que possui o mesmo estado interno que o processo
pai ). A evolução da variável X em um programa que se utilize da chamada de sistema
fork() teria como resultado um maior consumo de memória em virtude da replicação dos
processos solicitantes.
TODAS AS SAÍDAS:
CREATE.C
MacBook-Air-de-Avilah-2:~ avilahflavio$ ./create

t00: Olá!
t01: Olá!
t02: Olá!
t03: Olá!
t04: Olá!
t05: Olá!
t06: Olá!
t07: Olá!
t08: Olá!
t09: Olá!
t10: Olá!
t11: Olá!
t12: Olá!
t13: Olá!
t14: Olá!
t15: Olá!
t00: Tchau!
t01: Tchau!
t02: Tchau!
t03: Tchau!
t04: Tchau!
t05: Tchau!
t06: Tchau!
t07: Tchau!
t08: Tchau!
t09: Tchau!
t10: Tchau!
t11: Tchau!
t12: Tchau!
t13: Tchau!
t14: Tchau!
t15: Tchau!
JOIN.C
MacBook-Air-de-Avilah-2:~ avilahflavio$ nano join.c

MacBook-Air-de-Avilah-2:~ avilahflavio$ chmod 777 join.c
MacBook-Air-de-Avilah-2:~ avilahflavio$ gcc join.c -o lathered
MacBook-Air-de-Avilah-2:~ avilahflavio$ ./join
-bash: ./join: No such file or directory
MacBook-Air-de-Avilah-2:~ avilahflavio$ gcc join.c -o lpthread
MacBook-Air-de-Avilah-2:~ avilahflavio$ chmod 777 join
chmod: join: No such file or directory
MacBook-Air-de-Avilah-2:~ avilahflavio$ gcc join.c -o join
t00: Olá!
t01: Olá!
t02: Olá!
t03: Olá!
t04: Olá!
t05: Olá!
Main: aguardando thread 00
t06: Olá!
t07: Olá!
t08: Olá!
t09: Olá!
t10: Olá!
t11: Olá!
t12: Olá!
t13: Olá!
t14: Olá!
t15: Olá!
cleat02: Tchau!
t01: Tchau!
t00: Tchau!
t03: Tchau!
t04: Tchau!
t07: Tchau!
t05: Tchau!
t06: Tchau!
t08: Tchau!
t09: Tchau!
t10: Tchau!
t11: Tchau!
t12: Tchau!
t13: Tchau!
t14: Tchau!
t15: Tchau!
MacBook-Air-de-Avilah-2:~ avilahflavio$ clear
t00: Olá!
t01: Olá!
t02: Olá!
t03: Olá!
t04: Olá!
t05: Olá!
t06: Olá!
t07: Olá!
t08: Olá!
t09: Olá!
t10: Olá!
t11: Olá!
t12: Olá!
t13: Olá!
t14: Olá!
t15: Olá!
t00: Tchau!
t01: Tchau!
t02: Tchau!
t03: Tchau!
t04: Tchau!
t05: Tchau!
t06: Tchau!
t07: Tchau!
t08: Tchau!
t09: Tchau!
t10: Tchau!
t11: Tchau!
t12: Tchau!
t13: Tchau!
t14: Tchau!
t15: Tchau!
MacBook-Air-de-Avilah-2:~ avilahflavio$ clear
t00: Olá!
t01: Olá!
t02: Olá!
t03: Olá!
t04: Olá!
t05: Olá!
t06: Olá!
t07: Olá!
t08: Olá!
t09: Olá!
t10: Olá!
t11: Olá!
t12: Olá!
t13: Olá!
t14: Olá!
t15: Olá!
t01: Tchau!
t00: Tchau!
t03: Tchau!
t02: Tchau!
t04: Tchau!
t05: Tchau!
t06: Tchau!
t07: Tchau!
t08: Tchau!
t09: Tchau!
t10: Tchau!
t11: Tchau!
t12: Tchau!
t13: Tchau!
t14: Tchau!
t15: Tchau!
PRINTX.C
MacBook-Air-de-Avilah-2:~ avilahflavio$ ./printx

t00: Olá! (x=01)
t01: Olá! (x=02)
t02: Olá! (x=03)
t03: Olá! (x=04)
t04: Olá! (x=05)
t05: Olá! (x=06)
t06: Olá! (x=07)
t07: Olá! (x=08)
t08: Olá! (x=09)
t09: Olá! (x=10)
t10: Olá! (x=11)
t11: Olá! (x=12)
t12: Olá! (x=13)
t13: Olá! (x=14)
t14: Olá! (x=15)
t15: Olá! (x=16)
t00: Tchau! (x=17)
t03: Tchau! (x=18)
t01: Tchau! (x=19)
t04: Tchau! (x=20)
t02: Tchau! (x=21)
t05: Tchau! (x=22)
t06: Tchau! (x=23)
t08: Tchau! (x=24)
t07: Tchau! (x=25)
t09: Tchau! (x=26)
t10: Tchau! (x=27)
t11: Tchau! (x=28)
t12: Tchau! (x=29)
t14: Tchau! (x=31)
t13: Tchau! (x=30)
t15: Tchau! (x=32)

Threads

Enviado por

Dados do documento

Título original

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

#include <pthread.h> // Incluir pthread funções e estruturas de dados

#define NUM_THREAD 16 // Define um número máximo de 12 Threads

printf ("t%02ld: Olá!\n", tid) ; // formata e exibe

pthread_exit (NULL) ; //* A chamada desta funçāo provoca a terminaçāo da thread e a

int main (int argc, char *argv[])

for (i=0; i<NUM_THREADS; i++)

status = pthread_create (&thread[i], NULL, threadBody, (void *) i) ;

#include <pthread.h> // Incluir pthread funções e estruturas de dados

#define NUM_THREAD 16 // Define um número máximo de 12 Threads

pthread_exit (NULL): A chamada desta funçāo provoca a terminaçāo da thread e a

A função Main cria as threadS conforme a figura de execução do código create.c.

2. A ordem de criação , ativação e encerramento não é a mesma. Segundo o código as

#include <pthread.h> // Incluir pthread funções e estruturas de dados

#define NUM_THREAD 16 // Define um número máximo de 16 Threads

A Função phtread_join() suspende a execução da thread chamadora até que a thread

tid: é a identificação da thread.

Para alterar-mos os atributos de uma thread, a variável do atributo é inicializara

pthread_create(thread, attire, função, argumento)

ATTR: É utilizado para definição as propriedades do thread. Podem-se especificar os

pthread_exit(estado): Esta função termina explicitamente um thread, Utiliza-se esta

#define NUM_THREADS 16 // Define um máximo de 16 thread

void *threadBody (void *id)

int main (int argc, char *argv[])

for (i=0; i<NUM_THREADS; i++)

status = pthread_create (&thread[i], NULL, threadBody, (void *) i) ;

MacBook-Air-de-Avilah-2:~ avilahflavio$ ./printx

MacBook-Air-de-Avilah-2:~ avilahflavio$ ./create

MacBook-Air-de-Avilah-2:~ avilahflavio$ nano join.c

MacBook-Air-de-Avilah-2:~ avilahflavio$ ./printx

Você também pode gostar

void threadBody (void id)