1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
CriarThread.cpp
#include <pthread.h>
#include <sched.h>
#include <stdio.h>
#include <stdiostream.h>
#include <iostream>
#include <stdlib.h>
#include <cstdlib>
#include <iostream>
#include <sys/types.h>
#include <process.h>
#include <string.h>
#include "CriarThread.h"
pthread_mutex_t myMutex;
pthread_attr_t myAttr;
/*----------Cria o ID da Thread de forma global----------*/
pthread_t t1;
using namespace std;
void *ExecutaAcao(void *ptr);
/*----------Construtores----------*/
CriarThread::CriarThread() {
// TODO Auto-generated constructor stub
}
/*----------Destrutores----------*/
CriarThread::~CriarThread() {
// TODO Auto-generated destructor stub
}
/*----------Cria um nova Thread----------*/
void CriarThread::NovaThread(){
int result=0;
char *msg;
msg = "Thread ";
result = pthread_create(&t1, &myAttr, ExecutaAcao, (void *) msg);
if (result){
printf("ERRO:\nCódigo retornado na criação da PThread = %d", result);
exit(-1);
}
}
/*----------Cria o Atributo da nova Thread----------*/
void CriarThread::CriaAtributo(){
/*----------Declaração de Variáveis----------*/
int prio;
printf("Digite a prioridade da Thread:");
prio = getchar();
char *tipoSched;
printf("Digite o tipo de escalonamento:\n(FIFO, ROUND-ROBIN, OTHER, SPORADIC)\n");
strupr(gets(tipoSched));
char *estado;
printf("Digite seu estado de execucao:\n(SEPARADA ou UNIDA)\n");
strupr(gets(estado));
char *escopo;
printf("Digite o escopo de processamento da mesma:\n(SISTEMA ou PROCESSO)\n");
strupr(gets(escopo));
/*----------Inicia a estrutura do atributo----------*/
pthread_attr_init(&myAttr);
/* Altera o estado para "separado";
* torna a execução da Thread independente ou não das outras
*/
if (stricmp(estado, (char *)"SEPARADA"))
pthread_attr_setdetachstate(&myAttr, PTHREAD_CREATE_DETACHED);
else if (stricmp(estado, (char *)"UNIDA"))
pthread_attr_setdetachstate(&myAttr, PTHREAD_CREATE_JOINABLE);
/*----------Altera o escopo de execução da Thread----------*/
/* .1 - Escopo SISTEMA = As threads competem pelo tempo de processamento
* conforme a divisão do sistema operacional.
*/
if (stricmp(escopo, (char *)"SISTEMA"))
pthread_attr_setscope(&myAttr, PTHREAD_SCOPE_SYSTEM);
/* .2 - Escopo PROCESSO = As threads competem internamente
* dentro do tempo que o processo que as criou possui.
*/
else if (stricmp(escopo, (char *)"PROCESSO"))
pthread_attr_setscope(&myAttr, PTHREAD_SCOPE_PROCESS);
/* Sobrescreve o valor padrão da opção INHERITED_SCHED (define se thread
* recém-criada herdará os parâmetros e políticas de thread criadora).
* A macro PTHREAD_EXPLICIT_SCHED define que a nova pthread
* deverá usar os valores da variável atributo.
*/
pthread_attr_setinheritsched(&myAttr, PTHREAD_EXPLICIT_SCHED);
/*----------Define a política de escalonamento da Thread----------*/
/* .1 - A primeira política, a First-in First-out (SCHED_FIFO),
* leva o escalonador ao comportamento de quem chegar primeiro.
* Caso possuam a mesma prioridade, a que chegou primeiro na fila
* de escalonamento conseguirá utilizar o espaço de memória.
* Caso as duas threads possuam prioridades distintas, a de maior
* valor vencerá a disputa.
*/
if (stricmp(tipoSched, (char *)"FIFO"))
pthread_attr_setschedpolicy(&myAttr, SCHED_FIFO);
/* .2 - Na segunda política, Round-Robin (SCHED_RR), as threads de igual
* prioridade serão escalonadas conforme as frações de tempo para cada
* processo em partes iguais e de forma circular, sem manipulação de
* todos os processos, podendo algumas delas sofrer por preempções.
*/
else if (stricmp(tipoSched, (char *)"ROUND-ROBIN"))
pthread_attr_setschedpolicy(&myAttr, SCHED_RR);
/* .3 - A terceira política, definida pela macro SCHED_OTHER,
* é usada para sinalizar que as threads não mais precisam de uma
* política específica de escalonamento.
*/
else if (stricmp(tipoSched, (char *)"OTHER"))
pthread_attr_setschedpolicy(&myAttr, SCHED_RR);
/* .4 - Na quarta, SCHED_SPORADIC, os processos são ativados irregularmente,
* porém com um intervalo mínimo entre duas invocações consecutivas
* do mesmo processo; implementação do servidor esporádico usada para
* executar processos aperiódicos.
*/
else if (stricmp(tipoSched, (char *)"SPORADIC"))
pthread_attr_setschedpolicy(&myAttr, SCHED_SPORADIC);
/*----------Define o nível de prioridade----------*/
myAttr.param.sched_priority = prio;
}
void CriarThread::AguardaFimThread(){
pthread_join(t1, NULL);
}
void CriarThread::FinalizaThread(){
pthread_exit(NULL);
}
void CriarThread::AlocaMemoria(){
pthread_mutex_lock(&myMutex);
}
void CriarThread::LiberaMemoria(){
pthread_mutex_unlock(&myMutex);
}
void *ExecutaAcao(void *ptr){
char *msg;
msg = (char *) ptr;
for(int i = 0; i < 10000;i++){
cout <<" #" << i << endl;
}
}
|
