SISTEMAS OPERATIVOS:
Lección 5:
Hilos y Procesos
Jesús Carretero Pérez
Alejandro Calderón Mateos
José Daniel García Sánchez
Francisco Javier García Blas
José Manuel Pérez Lobato
María Gregoria Casares Andrés
• Introducción y conceptos básicos
Sistemas
Opera,vos
1
ADVERTENCIA
• Este
material
es
un
simple
guión
de
la
clase:
no
son
los
apuntes
de
la
asignatura.
• El
conocimiento
exclusivo
de
este
material
no
garanBza
que
el
alumno
pueda
alcanzar
los
objeBvos
de
la
asignatura.
• Se
recomienda
que
el
alumno
uBlice
los
materiales
complementarios
propuestos.
Sistemas
Opera,vos
2
Contenido
• Concepto
de
hilo.
• Modelos
de
hilos.
• Aspectos
de
diseño.
• Hilos
en
pthreads.
• Entorno
de
un
proceso.
• Señales.
• Temporizadores.
• Excepciones.
Sistemas
Opera,vos
3
Aplicaciones
con
tareas
concurrente
• Un
proceso
incluye
un
único
hilo
de
ejecución.
• Diseño
de
aplicación
con
varias
tareas
concurrentes:
– Un
proceso
receptor
de
peBciones
y
lanzar
un
proceso
por
peBción.
– Un
proceso
receptor
y
un
conjunto
fijo
de
procesos
de
tratamiento
de
peBciones.
Sistemas
Opera,vos
4
Rendimiento
de
aplicaciones
concurrentes
• Consumo
de
Bempo
en
la
creación
y
terminación
de
procesos.
• Consume
de
Bempo
en
cambios
de
contexto.
• Problemas
en
la
comparBción
de
recursos.
Sistemas
Opera,vos
5
Hilo,
Proceso
ligero
o
Thread
Sistemas
Opera,vos
6
Hilos
• La
mayoría
de
los
modernos
SO
proporcionan
procesos
con
múlBples
secuencias
o
hilos
de
control
en
su
interior.
• Se
considera
una
unidad
básica
de
uBlización
de
la
CPU.
• Cada
uno
comprende:
– IdenBficador
de
thread
– Contador
de
programa
– Conjunto
de
registros
– Pila
• Comparten
con
el
resto
de
hilos
del
proceso:
– Mapa
de
memoria
(sección
de
código,
sección
de
datos,
shmem)
– Ficheros
abiertos
– Señales,
semáforos
y
temporizadores.
Sistemas
Opera,vos
7
Beneficios
• Capacidad
de
respuesta.
– Mayor
interacBvidad
al
separar
las
interacciones
con
el
usuario
de
las
tareas
de
procesamiento
en
disBntos
hilos.
• ComparBción
de
recursos.
– Los
hilos
comparten
la
mayor
parte
de
los
recursos
de
forma
automáBca.
• Economía
de
recursos.
– Crear
un
proceso
consume
mucho
más
Bempo
que
crear
un
hilo
(Ejemplo:
en
Solaris
relación
30
a
1).
• UBlización
sobre
arquitecturas
mulBprocesador.
– Mayor
nivel
de
concurrencia
asignando
disBntos
hilos
a
disBntos
procesadores.
– La
mayoría
de
los
sistemas
operaBvos
modernos
usan
el
hilo
como
unidad
de
planificación.
Sistemas
Opera,vos
8
Soporte
de
hilos
• Espacio
de
usuario
• Espacio
de
núcleo
• ULT
–
User
Level
Threads
• KLT
–
Kernel
Level
Threads
• Implementados
en
forma
de
• El
kernel
se
ocupa
de
crearlos,
biblioteca
de
funciones
en
espacio
planificarlos
y
destruirlos.
de
usuario.
• Es
un
poco
más
lento
ya
que
hacemos
parBcipar
al
kernel
y
esto
supone
un
• El
kernel
no
Bene
conocimiento
cambio
de
modo
de
ejecución.
sobre
ellos,
no
ofrece
soporte
de
• En
llamadas
al
sistema
bloqueantes
sólo
ningún
Bpo.
se
bloquea
el
thread
implicado.
• Es
mucho
más
rápido
pero
• En
sistemas
SMP,
varios
threads
pueden
presentan
algunos
problemas
→
ejecutarse
a
la
vez.
Llamadas
al
sistema
bloqueantes.
• No
hay
código
de
soporte
para
thread
en
las
aplicaciones.
• El
kernel
también
puede
usar
threads
para
llevar
a
cabo
sus
funciones.
Sistemas
Opera,vos
9
Contenido
• Concepto
de
hilo.
• Modelos
de
hilos.
• Aspectos
de
diseño.
• Hilos
en
pthreads.
• Entorno
de
un
proceso.
• Señales.
• Temporizadores.
• Excepciones.
Sistemas
Opera,vos
10
Modelos
de
múlBples
hilos:
Muchos
a
uno
• Hace
corresponder
múlBples
hilos
de
usuario
a
un
único
hilo
del
núcleo.
h1 h2 … hn
• Biblioteca
de
hilos
en
espacio
de
usuario.
• Llamada
bloqueante:
Biblioteca de hilos
– Se
bloquean
todos
los
hilos.
• En
mulBprocesadores
no
se
pueden
ejecutar
varios
k1
hilos
a
la
vez.
Sistemas
Opera,vos
11
Modelo
de
múlBples
hilos:
Uno
a
uno
• Hace
corresponder
un
hilo
del
kernel
a
cada
hilo
de
h1 h2 … hn
usuario.
• La
mayoría
de
las
implementaciones
restringen
el
número
de
hilos
que
se
pueden
crear.
• Ejemplos:
– Linux
2.6.
…
– Windows.
k1 k2 kn
– Solaris
9.
Sistemas
Opera,vos
12
Modelos
de
múlBples
hilos:
Muchos
a
muchos
• Este
modelo
mulBplexa
los
threads
de
usuario
en
…
un
número
determinado
h1 h2 hn
de
threads
en
el
kernel.
• El
núcleo
del
sistema
operaBvo
se
complica
mucho.
• Ejemplos:
– Solaris
(versiones
k
…
anteriores
a
9).
k1 k2
m
– HP-‐UX.
– IRIX.
Sistemas
Opera,vos
13
Contenido
• Concepto
de
hilo.
• Modelos
de
hilos.
• Aspectos
de
diseño.
• Hilos
en
pthreads.
• Entorno
de
un
proceso.
• Señales.
• Temporizadores.
• Excepciones.
Sistemas
Opera,vos
14
Llamadas
a
fork
y
exec
• En
los
sistemas
Bpo
UNIX
¿Qué
se
debe
hacer
si
se
llama
a
fork
desde
un
hilo?
– Duplicar
el
proceso
con
todos
sus
hilos.
• Apropiado
si
no
se
va
a
llamar
luego
a
exec
para
susBtuir
la
imagen
del
proceso.
– Duplicar
el
proceso
solo
con
el
hilo
que
llama
a
fork.
• Más
eficiente
si
se
va
a
llamar
a
exec
y
se
van
a
cancelar
todos
los
hilos.
• Solución
en
Linux:
Dos
versiones
de
fork.
Sistemas
Opera,vos
15
Cancelación
de
hilos
• Situación
en
la
que
un
hilo
noBfica
a
otros
que
deben
terminar.
• Opciones:
– Cancelación
asíncrona:
Se
fuerza
la
terminación
inmediata
del
hilo.
• Problemas
con
los
recursos
asignados
al
hilo.
– Cancelación
diferida:
El
hilo
comprueba
periódicamente
si
debe
terminar.
• Preferible.
Sistemas
Opera,vos
16
Hilos
y
procesamiento
de
solicitudes
• Las
aplicaciones
que
reciben
peBciones
y
las
procesan
pueden
usar
hilos
para
el
tratamiento.
• Pero:
– El
Bempo
de
creación/destrucción
del
hilo
supone
un
retraso
(aunque
sea
menor
que
el
de
creación/destrucción
de
un
proceso).
– No
se
establece
un
límite
en
el
número
de
hilos
concurrentes.
– Si
llega
una
avalancha
de
peBciones
se
pueden
agotar
los
recursos
del
sistema.
Sistemas
Opera,vos
17
Thread
Pools
o
Conjuntos
de
Hilos
• Se
crea
un
conjunto
de
hilos
que
quedan
en
espera
a
que
lleguen
peBciones.
• Ventajas:
– Se
minimiza
el
retardo:
El
hilo
ya
existe.
– Se
manBene
un
límite
sobre
el
número
de
hilos
concurrentes.
Sistemas
Opera,vos
18
Contenido
• Concepto
de
hilo.
• Modelos
de
hilos.
• Aspectos
de
diseño.
• Hilos
en
pthreads.
• Entorno
de
un
proceso.
• Señales.
• Temporizadores.
• Excepciones.
Sistemas
Opera,vos
19
Creación
de
hilos
• int pthread_create(pthread_t *thread,
const pthread_attr_t *attr,
void *(*func)(void *),
void *arg)
– Crea
un
hilo
e
inicia
su
ejecución.
– thread:
Se
debe
pasar
la
dirección
de
una
variable
del
Bpo
pthread_t
que
se
usa
como
manejador
del
hilo.
– a;r:
Se
debe
pasar
la
dirección
de
una
estructura
con
los
atributos
del
hilo.
Se
puede
pasar
NULL
para
usar
atributos
por
defecto.
– func:
Función
con
el
código
de
ejecución
del
hilo.
– arg:
Puntero
al
parámetro
del
hilo.
Solamente
se
puede
pasar
un
parámetro.
• pthread_t pthread_self(void)
– Devuelve
el
idenBficador
del
thread
que
ejecuta
la
llamada.
Sistemas
Opera,vos
20
Espera
y
terminación
• int pthread_join(pthread_t thread,
void **value)
– El
hilo
que
invoca
la
función
se
espera
hasta
que
el
hilo
cuyo
manejador
se
especifique
haya
terminado.
– thread:
Manejador
de
del
hilo
al
que
hay
que
esperar.
– value:
Valor
de
terminación
del
hilo.
• int pthread_exit(void *value)
– Permite
a
un
proceso
ligero
finalizar
su
ejecución,
indicando
el
estado
de
terminación
del
mismo.
– El
estado
de
terminación
no
puede
ser
un
puntero
a
una
variable
local.
Sistemas
Opera,vos
21
Ejemplo
#include <stdio.h>
#include <pthread.h> int main() {
pthread_t th1, th2;
struct sumapar { sumapar_t s1 = {1,50,0};
int n, m, r; sumapar_t s2 = {51,100,0};
};
typedef struct sumapar sumapar_t; pthread_create(&th1, NULL,
(void*)suma, (void*)&s1);
pthread_create(&th2, NULL,
void suma(sumapar_t * par) { (void*)suma, (void*)&s2);
int i;
int suma=0; pthread_join(th1, NULL);
for (i=par->n;i<=par->m;i++) { pthread_join(th2, NULL);
suma +=i;
} printf("Suma=%d\n",
par->r=suma; s1.r+s2.r);
} }
Sistemas
Opera,vos
22
Atributos
de
un
hilo
• Cada
hilo
Bene
asociados
un
conjunto
de
atributos.
• Atributos
representados
por
una
variable
de
Bpo
pthread_a;r_t.
• Los
atributos
controlan:
– Un
hilo
es
independiente
o
dependiente.
– El
tamaño
de
la
pila
privada
del
hilo.
– La
localización
de
la
pila
del
hilo.
– La
políBca
de
planificación
del
hilo.
Sistemas
Opera,vos
23
Atributos
• int pthread_attr_init(pthread_attr_t * attr);
– Inicia
una
estructura
de
atributos
de
hilo.
• int pthread_attr_destroy(pthread_attr_t * attr);
– Destruye
una
estructura
de
atributos
de
hilo.
• int pthread_attr_setstacksize(pthread_attr_t *
attr, int stacksize);
– Define
el
tamaño
de
la
pila
para
un
hilo
• int pthread_attr_getstacksize(pthread_attr_t *
attr, int *stacksize);
– Permite
obtener
el
tamaño
de
la
pila
de
un
hilo.
Sistemas
Opera,vos
24
Hilos
dependientes
e
hilos
independientes
• int pthread_attr_setdetachstate(pthread_attr_t *attr,
int detachstate)
– Establece
el
estado
de
terminación
de
un
proceso
ligero.
– Si
"detachstate"
=
PTHREAD_CREATE_DETACHED
el
proceso
ligero
liberara
sus
recursos
cuando
finalice
su
ejecución.
– Si
"detachstate"
=
PTHREAD_CREATE_JOINABLE
no
se
liberan
los
recursos,
es
necesario
uBlizar
pthread_join().
• int pthread_attr_getdetachstate(pthread_attr_t *attr,
int *detachstate)
– Permite
conocer
el
estado
de
terminación
Sistemas
Opera,vos
25
Ejemplo:
Hilos
independientes
#include <stdio.h>
#include <pthread.h>
#define MAX_THREADS 10
void func(void) {
printf("Thread %d \n", pthread_self());
pthread_exit(0);
}
int main() {
int j;
pthread_attr_t attr;
pthread_t thid[MAX_THREADS];
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
for(j = 0; j < MAX_THREADS; j ++)
pthread_create(&thid[j], &attr, func, NULL);
sleep(5);
}
Sistemas
Opera,vos
26
Contenido
• Concepto
de
hilo.
• Modelos
de
hilos.
• Aspectos
de
diseño.
• Hilos
en
pthreads.
• Entorno
de
un
proceso.
• Señales.
• Temporizadores.
• Excepciones.
Sistemas
Opera,vos
27
Entorno
de
un
proceso
• Mecanismo
de
paso
de
información
a
un
proceso.
• Conjunto
e
pares
<nombre, valor>.
• Ejemplo
PATH=/usr/bin:/home/pepe/bin
TERM=vt100
HOME=/home/pepe
PWD=/home/pepe/libros/primero
TIMEZONE=MET
Sistemas
Opera,vos
28
Entorno
de
un
proceso
• El
entorno
de
un
proceso
se
coloca
en
la
pila
del
proceso
al
iniciarlo.
• Acceso:
– El
sistema
operaBvo
coloca
algunos
valores
por
defecto
(p.
ej.
PATH).
– Acceso
mediante
mandatos
(set,
export).
– Acceso
mediante
API
de
SO
(putenv,
getenv).
Sistemas
Opera,vos
29
Entorno
de
un
proceso
• Un
proceso
recibe
como
tercer
parámetro
de
main
la
dirección
de
la
tabla
de
variables
de
entorno.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv, char** envp) {
for (int i=0;envp[i]!=NULL;i++) {
printf(“%s\n”,envp[i]);
}
return 0;
}
Sistemas
Opera,vos
30
Entorno
de
un
proceso
• char * getenv(const char * var);
– ObBene
el
valor
de
una
variable
de
entorno.
• int setenv(const char * var, const char * val, int
overwrite);
– Modifica
o
añade
una
variable
de
entorno.
• int putenv(const char * par);
– Modifica
o
añade
una
asignación
var=valor
Sistemas
Opera,vos
31
Contenido
• Concepto
de
hilo.
• Modelos
de
hilos.
• Aspectos
de
diseño.
• Hilos
en
pthreads.
• Entorno
de
un
proceso.
• Señales.
• Temporizadores.
• Excepciones.
Sistemas
Opera,vos
32
Señales
• Son
un
mecanismo
que
permite
avisar
a
un
proceso
de
la
ocurrencia
de
un
evento.
• Ejemplos:
– Un
proceso
padre
recibe
la
señal
SIGCHLD
cuando
termina
un
proceso
hijo.
– Un
proceso
recibe
una
señal
SIGILL
cuando
intenta
ejecutar
una
instrucción
máquina
ilegal.
Son un mecanismo propio de los sistemas UNIX
Sistemas
Opera,vos
33
Señales
• Las
señales
son
interrupciones
al
proceso
• Envío
o
generación
– Proceso-‐
Proceso
(dentro
del
grupo)
con
el
kill
– SO
-‐
Proceso
Sistemas
Opera,vos
34
Señales
• Otras
señales
– SIGILL
instrucción
ilegal
– SIGALRM
vence
el
temporizador
– SIGKILL
mata
al
proceso
• Cuando
un
proceso
recibe
una
señal:
– Si
está
en
ejecución:
DeBene
su
ejecución
en
la
instrucción
máquina
actual.
– Si
existe
una
ruBna
de
tratamiento
de
la
señal:
Bifurcación
para
ejecutar
la
ruBna
de
tratamiento.
– Si
la
ruBna
de
tratamiento
no
termina
el
proceso:
Retorno
al
punto
en
que
se
recibió
la
señal.
Sistemas
Opera,vos
35
Señales
• Otras
señales
– SIGALRM
vence
el
temporizador
– SIGKILL
mata
al
proceso
• El
SO
las
transmite
al
proceso
– El
proceso
debe
estar
preparado
para
recibirla
• Especificando
un
procedimiento
de
señal
con
sigacBon.
• Enmascarando
la
señal
con
sigprogmask.
– Si
no
está
preparado
à
acción
por
defecto
• El
proceso,
en
general,
muere.
• Hay
algunas
señales
que
se
ignoran
o
Benen
otro
efecto.
• El
servicio
pause
para
el
proceso
hasta
que
recibe
una
señal
Sistemas
Opera,vos
36
Servicios
POSIX
para
la
gesBón
de
señales
• int kill(pid_t pid, int sig)
– Envía
al
proceso
"pid"
la
señal
"sig“.
– Casos
especiales:
• pid=0
à
Señal
a
todos
los
procesos
con
gid
igual
al
gid
del
proceso.
• pid
<
-‐1
à
Señal
a
todos
los
proceso
con
gid
igual
al
valor
absolute
de
pid.
• int sigaction(int sig,
struct sigaction *act,
struct sigaction *oact)
– Permite
especificar
la
acción
a
realizar
como
tratamiento
de
la
señal
"sig”
– La
configuración
anterior
se
puede
guardar
en
“oact”.
Sistemas
Opera,vos
37
La
estructura
sigacBon
struct sigaction {
void (*sa_handler)(); /* Manejador */
sigset_t sa_mask; /* Señales bloqueadas */
int sa_flags; /* Opciones */
};
• Manejador:
– SIG_DFL:
Acción
por
defecto
(normalmente
termina
el
proceso).
– SIG_IGN:
Ignora
la
señal.
– Dirección
de
una
función
de
tratamiento.
• Máscara
de
señales
a
bloquear
durante
el
manejador.
• Opciones
normalmente
a
cero.
Sistemas
Opera,vos
38
Conjuntos
de
señales
• int
sigemptyset(sigset_t
*
set);
– Crea
un
conjunto
vacío
de
señales.
• int
sigfillset(sigset_t
*
set);
– Crea
un
conjunto
lleno
con
todas
la
señales
posibles.
• int
sigaddset(sigset_t
*
set,
int
signo);
– Añade
una
señal
a
un
conjunto
de
señales.
• int
sigdelset(sigset_t
*
set,
int
signo);
– Borra
una
señal
de
un
conjunto
de
señales.
• int
sigismember(sigset_t
*
set,
int
signo);
– Comprueba
si
una
señal
pertenece
a
un
conjunto.
Sistemas
Opera,vos
39
Ejemplo
• Ignorar
la
señal
SIGINT
– Se
produce
cuando
se
pulsa
la
combinación
de
teclas
Ctrl
+C
struct sigaction act;
act.sa_handler = SIG_IGN;
act.flags = 0;
sigemptyset(&act.sa_mask);
Sigaction(SIGINT, &act, NULL);
Sistemas
Opera,vos
40
Servicios
POSIX
para
la
gesBón
de
señales
• int pause(void)
– Bloquea
al
proceso
hasta
la
recepción
de
una
señal.
– No
se
puede
especificar
un
plazo
para
desbloqueo.
– No
permite
indicar
el
Bpo
de
señal
que
se
espera.
– No
desbloquea
el
proceso
ante
señales
ignoradas.
• int
sleep(unsigned
int
sec)
– Suspende
un
proceso
hasta
que
vence
un
plazo
o
se
recibe
una
señal.
Sistemas
Opera,vos
41
Contenido
• Concepto
de
hilo.
• Modelos
de
hilos.
• Aspectos
de
diseño.
• Hilos
en
pthreads.
• Entorno
de
un
proceso.
• Señales.
• Temporizadores.
• Excepciones.
Sistemas
Opera,vos
42
Temporizadores
• El
sistema
operaBvo
manBene
un
temporizador
por
proceso
(caso
UNIX).
– Se
manBene
en
el
BCP
del
proceso
un
contador
del
Bempo
que
falta
para
que
venza
el
temporizador.
– La
ruBna
del
sistema
operaBvo
actualiza
todos
los
temporizadores.
– Si
un
temporizador
llega
a
cero
se
ejecuta
la
función
de
tratamiento.
• En
UNIX
el
sistema
operaBvo
envía
una
señal
SIGALRM
al
proceso
cuando
vence
su
temporizador.
Sistemas
Opera,vos
43
Servicios
POSIX
para
temporización
• int alarm(unsigned int sec)
– Establece
un
temporizador.
– Si
el
parámetro
es
cero,
desacBva
el
temporizador.
Sistemas
Opera,vos
44
Ejemplo:
Imprimir
un
mensaje
cada
10
segundos
#include <signal.h>
#include <stdio.h>
void tratar_alarma(void) {
printf("Activada \n");
}
int main() {
struct sigaction act;
/* establece el manejador para SIGALRM */
act.sa_handler = tratar_alarma;
act.sa_flags = 0; /* ninguna acción especifica */
sigaction(SIGALRM, &act, NULL);
act.sa_handler = SIG_IGN; /* ignora SIGINT */
sigaction(SIGINT, &act, NULL);
for(;;){ /* recibe SIGALRM cada 10 segundos */
alarm(10);
pause();
}
}
Sistemas
Opera,vos
45
Finalización
temporizada
#include <sys/types.h> switch(pid) {
#include <signal.h> case -1: /* error del fork() */
#include <stdio.h> perror ("fork");
exit(-1);
pid_t pid; case 0: /* proceso hijo */
void tratar_alarma(void) { execvp(argumentos[0], argumentos);
kill(pid, SIGKILL); perror("exec");
} exit(-1);
default: /* padre */
main(int argc, char **argv) { /* establece el manejador */
int status; act.sa_handler = tratar_alarma;
char **argumentos; act.sa_flags = 0;
struct sigaction act; sigaction(SIGALRM, &act, NULL);
argumentos = &argv[1]; alarm(5);
pid = fork(); wait(&status);
}
exit(0);
}
Sistemas
Opera,vos
46
Contenido
• Concepto
de
hilo.
• Modelos
de
hilos.
• Aspectos
de
diseño.
• Hilos
en
pthreads.
• Entorno
de
un
proceso.
• Señales.
• Temporizadores.
• Excepciones.
Sistemas
Opera,vos
47
Excepciones
• Win32
ofrece
una
gesBón
estructurada
de
excepciones.
• La
expresión
de
__except
debe
• Extensión
al
lenguaje
C
para
evaluarse
a:
gesBón
estructurada
de
excepciones.
• EXCEPTION_EXECUTE_HANDLER
– No
es
parte
de
ANSI/ISO
C.
– Entra
en
el
bloque.
• EXCEPTION_CONTINUE_SEARC
__try { H
/* Código principal */ – Propaga
la
excepción.
} • EXCEPTION_CONTINUE_EXECU
__except (expr) { TION
/* Tratamiento de – Ignora
la
excepción.
excepción */
}
Sistemas
Opera,vos
48
Código
de
excepción
• DWORD
GetExcepBonCode()
– No
es
una
llamada
al
sistema:
Macro.
– Solamente
se
puede
usar
dentro
de
tratamiento
de
excepciones.
– Existe
una
lista
larga
de
valores
que
puede
devolver:
• EXCEPTION_ACCESS_VIOLATION
• EXCEPTION_ILLEGAL_INSTRUCTION
• EXCEPTION_PRIV_INSTRUCTION
• ...
Sistemas
Opera,vos
49
Copia
de
cadenas
segura
LPTSTR CopiaSegura(LPTSTR s1, LPTSTR s2) {
__try {
return strcpy(s1,s2);
}
__except(GetExceptionCode()==EXCEPTION_ACCESS_VIOLATION?
EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
return NULL;
}
}
Sistemas
Opera,vos
50
Puntos
a
recordar
• Un
proceso
puede
tener
varios
hilos
de
ejecución.
• Una
aplicación
mulBhilo
consume
menos
recursos
que
una
aplicación
mulBproceso.
• Cada
sistema
operaBvo
Bene
un
modo
de
soporte
de
hilos
entre
ULT
y
KLT.
• PTHREADS
es
una
biblioteca
de
hilos
de
usuario.
• Win32
ofrece
hilos
en
el
núcleo
con
soporte
para
conjuntos
de
hilos
(Thread
Pools).
Sistemas
Opera,vos
51
Puntos
a
recordar
• Las
variables
de
entorno
permiten
pasar
información
a
los
procesos.
• Las
señales
POSIX
se
pueden
ignorar
o
tratar.
• Los
temporizadores
Benen
disBnta
resolución
de
POSIX
in
Win32.
• El
tratamiento
estructurado
de
excepciones
permiten
tratar
situaciones
anómalas
mediante
una
extensión
del
lenguaje
C.
Sistemas
Opera,vos
52
Lecturas
recomendadas
• Básica
• Complementaria
• Carretero
2007:
• Stallings
2005:
– 3.6.
Señales
y
excepciones.
– 4.1
Procesos
e
hilos.
– 4.4
GesBón
de
hilos
y
SMP
– 3.7.
Temporizadores.
en
Windows.
– 3.13.
Servicios.
– 4.5
GesBón
de
hilos
y
SMP
– 3.9
Threads
en
Solaris.
– 4.6
GesBón
de
procesos
e
hilos
en
Linux.
• Silberschatz
2006:
– 4
Hebras.
Sistemas
Opera,vos
53
SISTEMAS OPERATIVOS:
Lección 5:
Hilos y Procesos
Material Complementario
Sistemas
Opera,vos
54
Entorno
de
un
proceso
en
Windows
• DWORD GetEnvironmentVariable(LPCTSTR lpszName,
LPTSTR lpszValue, DWORD valueLenght);
– Devuelve
el
valor
de
una
variable
de
entorno.
• BOOL SetEnvironmentVariable(LPCTSTR lpszName,
LPTSTR lpszValue);
– Modifica
o
crea
una
variable
de
entorno.
• LPVOID GetEnvironmentStrings();
– ObBene
un
puntero
a
la
tabla
de
variables
de
entorno.
Sistemas
Opera,vos
55
Listado
de
variables
de
entorno
en
Windows
#include <windows.h>
#include <stdio.h> char * p = lpszVar;
while (p!=NULL) {
int main() { printf(“%s\n”,p);
char * lpszVar; while (p!=NULL) p++;
void * lpvEnv; p++;
}
lpvEnv =GetEnvironmentStrings();
if (lpvEnv == NULL) { printf(“\n”);
exit(-1); FreeEnvironmentStrings(lpszVar);
}
return 0;
}
Sistemas
Opera,vos
56
Temporizadores
en
Windows
• UINT SetTimer(HWND hWnd, UINT nIDEvent,
UINT uElapse, TIMERPROC lpTimerFunc);
– AcBva
un
temporizador
y
ejecuta
la
funció
lpTimerFunc
cuando
venza
el
Bempo.
– La
función
debe
cumplir
con:
• VOID
TimerFunc(HWND
hWnd,
UINT
uMsg,
UINT
idEvent,
DWORD
dwTime);
• BOOL KillTimer(HWND hWnd, UINT uIdEvent);
– DesacBva
un
temporizador.
• VOID Sleep(DWORD dwMilliseconds);
– Hace
que
el
hilo
actual
se
su
suspenda
durante
un
cierto
Bempo.
Sistemas
Opera,vos
57
Temporización
de
un
mensaje
en
Windows
#include <windows.h>
#include <stdio.h>
VOID Mensaje(HWND,UINT,UINT,DWORD) {
printf(“Tiempo finalizado”);
}
int main() {
tid = SetTimer(NULL,2,10,Mensaje); /* 2 msec */
realizar_tarea();
KillTimer(NULL,tid);
return 0;
}
Sistemas
Opera,vos
58
