Prática SO UNEB Threads

Prévia do material em texto

Threads
Michel Franc¸a Leal
Universidade do Estado da Bahia (UNEB)
Salvador - Bahia - Brasil
{mfrancaleal@gmail.com}
Resumo
O fa´cil acesso das pessoas aos computadores, a oferta
de servic¸os o avanc¸o da tecnoligia da informac¸a˜o obrigada
que os computadores se comportem de maneira mas ra´pida,
esta´vel e confia´vel. Os computadores antigos so´ conseguia
tratar de uma tarefa por processo o que nos tempos de hoje
seria um grande problema. A soluc¸a˜o para esse gargalo
computacional foram as Threads. Maziero(1) diz que uma
thread e´ um fluxo de execuc¸a˜o do sistema associado ou na˜o
a um processo ou no interior do nu´cleo. Veremos neste tra-
balho algo sobre threads tanto na pra´tica como teoria.
1. Introduc¸a˜o
Conforme o grau de complexidade dos computadores
ia aumentando, aumentava de forma proporcional a invi-
abilidade de lidar com apenas uma tarefa por processo.
Imaginemos um simples editor de texto, ele executa diver-
sos processos de forma simultaˆnea. Na˜o muito diferente
temos a rede de computadores que precisa lidar com o
acesso simultaˆneo de diversos usua´rios.
No inı´cio deste documento foi exposta a definic¸a˜o de
Maziero(1) que ainda divide as threads em duas categorias:
Threads de usua´rio(user-level ou user threads): Aquelas
que sa˜o executadas dentro de um processo e Threads de
nu´cleo(kernel-level threads ou kernel threads): Quando os
fluxos de execuc¸a˜o sa˜o reconhecidos e tratados pelo nu´cleo
do sistema operacional.
2. Questa˜o I
Explique a finalidade da func¸a˜o pthread join()
Esta func¸a˜o serve para dar uma pausa na execuc¸a˜o de uma
thread ate´ a conclusa˜o da tarefa de outra.
Segue abaixo, informac¸o˜es sobre a func¸a˜o segundo Cruz(2).
Assinatura da func¸a˜o:
int pthread join(pthread t tid, void
**status);
A thread declarada precisa pertencer ao processo atual e
na˜o deve ser detached1, como tambe´m, apenas uma thread
pode esperar o te´rmino da outra.
Argumentos:
• tid : A thread que chamou pthread join suspende a sua
execuc¸a˜o ate´ que a thread identificada por tid termine,
ou chamando pthread exit ou sendo cancelada.
• status : Um ponteiro para o local onde o valor de
retorno da func¸a˜o tid e´ colocado. Este valor ou e´ o
argumento dado para a func¸a˜o pthread exit ou PTH-
READ CANCELLED se ela foi cancelada.
Valores retornados:
• EINVAL : tid na˜o e´ uma thread va´lida.
• ESRCH : tid na˜o e´ thread va´lida e descolada do pro-
cesso atual.
• EDEADLK : tid especifica a thread que chamou.
3. Questa˜o II
Criar um programa em C com 5 threads. Cada thread
deve imprimir a mensagem: ”Sou a thread X”. Onde
”X”corresponde ao ı´ndice de criac¸a˜o da thread que deve
ser passado por paraˆmetro para a func¸a˜o que a thread
executara´.
Segue o co´digo:
1Este tipo de thread apo´s concluir sua execuc¸a˜o, libera todos os recur-
sos e termina.
1 # i n c l u d e <p t h r e a d . h>
2 # i n c l u d e <s t d i o . h>
3 # i n c l u d e < s t d l i b . h>
4 # d e f i n e N THREADS 8
5
6 vo id ∗ I m p r i m i r ( vo id ∗ i )
7 {
8 p r i n t f ( ” Sou a t h r e a d %d\n ” , ( i n t ) i ) ;
9 p t h r e a d e x i t (NULL) ;
10 }
11 i n t main ( )
12 {
13 p t h r e a d t t h r e a d s [N THREADS ] ;
14 i n t i =0 ;
15 f o r ( i ; i<N THREADS ; i ++)
16 p t h r e a d c r e a t e (& t h r e a d s [ i ] , NULL,
Impr imi r , ( vo id ∗ ) i ) ;
17 f o r ( i ; i<N THREADS ; i ++)
18 p t h r e a d j o i n ( t h r e a d s [ i ] , NULL) ;
19 r e t u r n 0 ;
20 }
Listing 1. Co´digo fonte q2.c
4. Questa˜o III
[PASSANDO O CONTEU´DO DE UMA VARIA´VEL
PARA UMA THREAD]
Escreva um programa que tenha dois threads: o principal,
no qual haja um varia´vel chamada a =1 e um segundo,
riado em seguida, que devera´ multiplicar a por 2.
Vide o co´digo na pro´xima pa´gina:
1 # i n c l u d e <p t h r e a d . h>
2 # i n c l u d e <s t d i o . h>
3 # d e f i n e NUM THREADS 2
4
5 vo id ∗ I n i c i a l i z a ( i n t ∗ i )
6 {
7 i n t ∗a= i ;
8 ∗a = 1 ;
9 p t h r e a d e x i t (NULL) ;
10 }
11 vo id ∗M u l t i p l i c a ( i n t ∗ i )
12 {
13 i n t ∗a = i ;
14 ∗a = ∗ ( a ) ∗2 ;
15 p r i n t f ( ” Va lo r de a %d\n ” , ∗a ) ;
16 p t h r e a d e x i t (NULL) ;
17 }
18 i n t main ( )
19 {
20 i n t i ;
21 p t h r e a d t t h r e a d 1 , t h r e a d 2 ;
22 p t h r e a d c r e a t e (& t h r e a d 1 , NULL, ( vo id ∗ )
I n i c i a l i z a , ( i n t ∗ )&i ) ;
23 p t h r e a d c r e a t e (& t h r e a d 2 , NULL, ( vo id ∗ )
M u l t i p l i c a , ( i n t ∗ )&i ) ;
24 p t h r e a d j o i n ( t h r e a d 1 , NULL) ;
25 p t h r e a d j o i n ( t h r e a d 2 , NULL) ;
26
27 r e t u r n 0 ;
28 }
Listing 2. Co´digo fonte q3.c
5. Questa˜o IV
[SOMATO´RIO DE THREADS]
Desenvolva uma func¸a˜o que soma todos os valores
entre 1 e 10000000, um a um (1+2 na primeira iterac¸a˜o,
3+3 na segunda, 6+4 na terceira, 10+5 na quarta,”etc.),
utilizando threads. Implemente um programa que, dado
um paraˆmetro nume´rico ”N”(um nu´mero inteiro maior ou
igual a 1), cria ”N”threads a partir dessa func¸a˜o e as inicia.
Seu programa deve tambe´m registrar quanto tempo, em
milissegundos, o programa leva para ser executado. Para
fazer isso, lembre-se que e´ necessa´rio esperar que todas as
threads terminem.
Vide Co´digo na pro´xima pa´gina
1 # i n c l u d e <s t d i o . h>
2 # i n c l u d e <p t h r e a d . h>
3 # i n c l u d e <t ime . h>
4
5 # d e f i n e MAX 1000000
6 u n s i g n e d long soma =0;
7
8 vo id ∗Soma ( vo id ∗ i )
9 {
10 l ong auxSoma = ( long ) i ;
11 soma+=auxSoma ;
12 p t h r e a d e x i t (NULL) ;
13 }
14
15 i n t main ( i n t N)
16 {
17 c l o c k t t e m p o I n i c i a l , t e m p o F i n a l ;
18 do ub l e tempoGasto ;
19 t e m p o I n i c i a l = c l o c k ( ) ;
20
21 i n t i , q = MAX/N, t =1 , s =1 ;
22 p t h r e a d t t h r e a d s [N ] ;
23
24
25 f o r ( i =1 ; i<=MAX; i ++ , t ++)
26 {
27 i f ( t>q )
28 {
29 t =1 ;
30 s ++;
31 }
32 e l s e
33 {
34 p t h r e a d c r e a t e (& t h r e a d s [ s−1] ,NULL,
Soma , ( vo id ∗ ) i ) ;
35 p t h r e a d j o i n ( t h r e a d s [ s−1] ,NULL) ;
36 }
37 }
38 t e m p o F i n a l = c l o c k ( ) ;
39 tempoGasto = ( ( t empoFina l−t e m p o I n i c i a l ) /
CLOCKS PER SEC ) ;
40 p r i n t f ( ”Tempo g a s t o : %f \” , tempoGasto ) ;
41 p r i n t f ( ”%l d \n ” , soma ) ;
42 r e t u r n 0 ;
43 }
Listing 3. Co´digo fonte q4.c
6. Conclusa˜o
O´tima atividade com teoria e pra´tica sobre threads.
Grande evoluc¸a˜o da tecnologia da informac¸a˜o otimizando
processamento de co´digos complexos.
Refereˆncias
[1] C. A. Maziero. (2008) Sistemas operacionais
2 - gereˆncia de tarefas. [Online]. Available:
http://www.ppgia.pucpr.br/maziero
[2] A. J. de Oliveira Cruz. (203) Thre-
ads, o que sa˜o? [Online]. Available:
http://equipe.nce.ufrj.br/adriano/tep/bibliogr/threads/threads.html