Procesos e hilos - elai.upm.es · La unidad de procesamiento gestionada por el S.O. Presencia en...
-
Upload
truonghanh -
Category
Documents
-
view
214 -
download
0
Transcript of Procesos e hilos - elai.upm.es · La unidad de procesamiento gestionada por el S.O. Presencia en...
Procesos e hilosPablo San Segundo (C-206)
KERNEL DEL SISTEMA OPERATIVO
Al arrancar el PC siempre se carga en memoria una copia del Kernel desde disco
El Kernel del sistema operativo es un programa,
típicamente programado en C
¿Qué es un Proceso?
Un programa en ejecuciónLa unidad de procesamiento gestionada por el S.O.
Presencia en memoria y tabla BCP
Registros de la CPUContexto
EntornoIdentificadores de usuario y grupoIdentificador de procesoVariables de entorno
UsuarioSistema
Control (tablas)Estado: Bloqueado, ejecución, listoPrioridad: cola de prioridadesE/S: Desc. recursos, ,mensajería etc.Presencia en memoria
typedef struct bcp {
struct bcp *siguiente; struct bcp *anterior; struct bcp *hebraint retardo; palabra marco; palabra pila; palabra marcador; int pri; int estado; struct bcp *todosenl; int mascara; k_ptrmens retenmensprocnombre nombre;
} bcp;
Bloque de Control de Proceso
ESTADOS BÁSICOS DE UN PROCESO
EN EJECUCIÓNUn proceso por procesador
BLOQUEADOEn espera de completar E/S
LISTOPreparado para pasar al estado de ejecución
ENTORNO DEL PROCESO
DefiniciónTabla NOMBRE-VALOR que se pasa al proceso en su creación
UbicaciónImagen en Memoria: típicamente en la pila
ValorPor defectoMandatos Shell (API S.O.)
PATH=/usr/bin:/home/pss/bin
TERM=tty100
HOME=/home/pss
PDW=/home/pss/ingsw
SHELL
echo $PATHecho $HOME
SHELL
PATH=$PATH:XXX
CARACTERÍSTICAS DE PROCESOS
Jerarquías (familias)Procesos hijo, padre, hermano, abuelo etc..
VidaCreaciónEjecuciónMuerte
Tipo de ejecuciónBatch (lotes)Interactivo
INI
INI SES INI SES
SHELL SHELL
PROC 1 PROC 2
USUARIO
DefiniciónPersona autorizada a utilizar el sistema
AutenticaciónUser login (internamente es un número para el S.O.: i.e uid)Contraseña (password)
Super-usuario (sudo, su)
Derechos de administrador
Grupo de usuariosColectivo de usuarios con los mismos permisosTodo usuario ha de pertenecer a un grupo
FIN DE INTRODUCCIÓN
Clasificación de los Sistemas Operativos
Fundamento del multiproceso
DefiniciónEjecución concurrente real de varios procesos con un solo procesador
BasesAlternancia de los procesos en la CPU durante la fase de E/SAlmacenamiento en memoria de varios procesos simultáneamente
Ejemplo
Ejecución de proceso nulo
VENTAJAS DE LA MULTITAREA
Funcionamiento del SO en modo ‘interactivo’ de forma eficiente
Aprovecha tiempos de espera de procesos durante E/SAumenta el uso de la CPU
Nuevo paradigma de programaciónPrincipio de ‘modularidad’: Un programa-varios
‘procesos’
GRADO DE MULTIPROGRAMACIÓN
DefiniciónNúmero de procesos activos en un instante de tiempo
RecursoMemoria principal
Sistema SIN memoria virtual
GRADO DE MULTIPROGRAMACIÓN
Sistema CON memoria virtual
GRADO DE MULTIPROGRAMACIÓN
Sistema CON memoria virtual
RENDIMIENTO DEL PROCESADOR
HIPER-PAGINACIÓN
FIN DE S.O. MULTITAREA
INFORMACIÓN DEL PROCESO EN S.O.i.e. RIED
Se gestionan fuera del BCP. ¿Por qué?
CODIGO
PILA
DATOS
ESTADO DEL PROCESO : CONTEXTORegistros generales
Motorola 68000: A0-A7, D0-D7Contador de programa (PC)
Siguiente instrucción a ejecutarPuntero de Pila (“Call Stack pointer”)
Referencia la pila en memoria asociado a todo procesoMotorola 68000 (USP y SSP)
Puntero de marco (“Frame pointer”)Registro de Estado
Modo de ejecución, máscaras de interrupciones, información acerca de la última operación realizada en la ALU, etc…Motorola 68000 (SR)
Registros especialesEjemplo: RIED: Registro que Identifica el Espacio de Direcciones que ocupa en memoria el proceso en ejecución
PROCESO EN MEMORIA
Pertenece al BCP
Preasignación inicial de zona de swapping
Segmentación fija Hoy en día la segmentación es variable
TABLAS DEL SISTEMA OPERATIVO
Tabla de procesos (BCP)Información exclusiva de cada proceso que no se puede COMPARTIR y cuyo tamaño no varía durante la ejecución de cada proceso (IMPLEMENTACIÓN)
Tabla de Memoria (alias paginado)Información para la gestión de memoria
Tabla de Entrada / SalidaInformación relativa a periféricos y a las operaciones E/S
Tabla de FicherosInformación sobre los ficheros utilizados por los procesos
Ejemplo Tabla de Ficheros
COMPARTEN LECTURA Y ESCRITURA EN FICHERO
Puntero de posición
TABLA DE FICHEROS
Doble direccionamiento
EJEMPLO: INFORMACIÓN EN EL BCP
TREEPS (LINUX)
FIN DE PRESENCIA EN MEMORIA DE
UN PROCESO
NACIMIENTO DE UN PROCESO
Linker
A imagen en memoria
Transmisión de ficheros al Motorola 68000
e.g. kernel.lib/dll
FORMACIÓN DE UN PROCESO
EL EJECUTABLE NO CONTIENE A LAS BIBLIOTECAS DEL SISTEMA
COPIA DE LAS BIBLIOTECAS DEL SISTEMA EN LA IMAGEN DE MEMORIA
(kernel.lib)
Tablas S.O.
SE ACTUALIZA LA PRIMERA VEZ Y EN CADA CAMBIO DE CONTEXTO
FIN DE FORMACIÓN DE UN PROCESO
SERVICIOS DE GESTIÓN DE PROCESOS
Identificación de procesosEntorno de un procesoCreación de procesosCambio de imagen de un procesoEspera a la terminación de un procesoFinalización de la ejecución de un procesoInformación adicional
SERVICIO POSIX: fork
Definiciónpid_t fork (void) : Crea un proceso hijo clonando al padre.
Copia no exacta (i.e. señales)
Librerías#include <sys/types.h>
RetornoIdentificador de proceso padre0 hijo-1 si error
DescripciónCrea un proceso hijo que ejecuta el mismo programa que el padreSe heredan los descriptores (i.e. archivos)Se desactivan las alarmas pendientes
SERVICIO POSIX: fork
Depende de la distribución
SERVICIO POSIX: exec
DefiniciónCambia el programa del proceso
Los descriptores abiertos se mantienen
EJEMPLO: Servicio fork
int main() { pid_t pid;pid=fork();if (pid= = -1)
cout<<“Error”<<endl;else if (pid == 0) {
cout<<“Proceso hijo”<<endl;} else{
cout<<“Proceso padre”<<endl;}
return 0;}
#include <sys/types.h>#include <iostream>
SERVICIO POSIX: exec
Declaracionesint execl (const char* path, const char* arg,…)int execlp(const char* file, const char* arg,…)int execvp(const char* file, const char* arg[])
Retorno-1 si error o NO RETORNA
DescripciónEl mismo proceso ejecuta otro programaLos descriptores abiertos permanecen abiertosLas señales toman la acción por defecto
Ultimo parámetro NULL
#include <unistd.h>
EJEMPLO: Servicio execl
int main() { pid_t pid;if ((pid = fork()) = = -1)
cout<<“Error”<<endl;else if (pid == 0) {
if(execl ("/bin/ls, “ls", “-l”, NULL)){ cout<<“Error al lanzar la tarea”<<endl;
}}int status;wait(&satus);
return 0;}
#include <sys/types.h>#include <unistd.h>#include <iostream>
EJEMPLO: Servicio execv
int main() { pid_t pid;char * arg[3];arg[0]=“gedit”; arg[1]=“test.cpp”;arg[2]=NULL;if ((pid = fork()) = = -1)
cout<<“Error”<<endl;else if (pid == 0) {
if(execvp (arg[0], arg)){ cout<<“Error al lanzar la tarea”<<endl;
}}int status;wait(&satus);
return 0;}
#include <sys/types.h>#include <unistd.h>#include <iostream>
SERVICIO POSIX: int exit (int status)Definición
Termina un proceso, devolviendo el parámetro status al proceso padre
Declaraciónvoid exit (int status)
EXIT_SUCCESS, EXIT_FAILUREArgumento
Código de retorno al proceso padreDescripción
Finaliza la ejecución del procesoCierra todos los descriptoresSe liberan todos los recursos
#include <stdlib.h>
SERVICIO POSIX: waitDefinición
Espera la terminación de un proceso hijo CUALQUIERADeclaración
pid_t wait (int* status)pid_t waitpid (int pid, int* status, int options)
RetornoIdentificador del proceso hijo, -1 si error
DescripciónPermite a un proceso padre esperar hasta que termine un proceso hijoDevuelve el estado del proceso hijo al terminar
Macros para analizar el estado: WIFEXITED, WEXITSTATUSWIFSIGNALED, WTERMSIG, etc…
WUNTRACEDWNOHANG
#include <sys/wait.h>
EJEMPLO : Servicio wait con MACROSint main(){
int status;pid_t pid;pid= fork();if(pid==0){
execlp(“gedit”, “main.cpp”, NULL);exit(EXIT_SUCCESS);
}wait(&status) ;if(WIFEXITED(status)){
if(WEXITSATUS(status)==EXIT_SUCCESS){cout<<“OK”<<endl;
}else if(WEXITSATUS(status)==EXIT_FAILURE)){cout<<“ERROR”<<endl;
}}cout<<"Proceso padre terminado"<<endl;
exit(EXIT_SUCCESS);}
Capturar el error
EJEMPLO : Servicio wait multiproceso
int main(){
int status;pid_t pid;for(int i=0; i<10; i++){
pid= fork();if(pid==0){
cout<<"hilo: "<<i<<endl;exit(EXIT_SUCCESS);
}}
//Espera a todos los hijoswhile ( wait(&status) !=-1 ){;}cout<<"Proceso padre terminado"<<endl;
exit(EXIT_SUCCESS);}
EJEMPLO: waitpidint main(void){
int status;pid_t pid;pid= fork();if(pid==0){
sleep(5);cout<<"proceso hijo terminado"<<endl;exit (EXIT_SUCCESS);
}
pid_t endid= waitpid(pid,&status, WNOHANG); //no bloqueanteif(endid==pid){
cout<<"status del hijo diposnible"<<endl;} else{
cout<<"padre termina sin conocer el status del hjo"<<endl;}
exit (EXIT_SUCCESS);}
Caso de uso típico de exec /fork /wait
Padre e hijo comparten recursos
EVOLUCIÓN DE PROCESOS: ZOMBIES
El hijo muere antes de la ejecución de un servicio wait(…) del padre
Hijo: Proceso ZOMBIE
BCP de B sigue existiendo
EJEMPLO: Zombies
int main(void){
pid_t pid;pid= fork();switch(pid){
case -1:cout<<"Error al creado proceso duplicado"<<endl;exit(EXIT_FAILURE);
break;case 0:sleep(1);cout<<"proceso hijo terminado"<<endl;exit(EXIT_SUCCESS);
break;}
cout<<“hijo terminará sin wait del padre: ¡ZOMBIE!"<<endl;sleep(30);int status;wait(&status);
exit(EXIT_SUCESS);}
EJEMPLO: JERARQUÍAS DE PROCESOS
int main (int argc, char** argv ){
int i, valor;pid_t pid_1, pid_2;
i=atoi(argv[1]);pid_1=fork();
while(i>0){pid_2=fork();if(pid_2!=0) {
wait(&valor)break;
}i=i-1;
}return 0;}
#include <sys/types.h>
<Nombre Ejecutable> 3
Ejecución desde Terminal
¿JERARQUÍA DE PROCESOS ?
A) Figura
B) Sin Bloque
#include <sys/wait.h>
Ejercicio: Procesos distribuidos (I)
Impleméntese un proceso que lance latarea de leer un grafo en formato DIMACSde un fichero de texto y devuelva su gradoen pantalla.
El proceso principal debe esperar a laterminación de dicha tarea e indicar si seha resuelto correctamente.
FIN DE SERVICIOS POSIX PARA PROCESOS
ESTADOS DE UN PROCESO
SWAPPING
PlanificadorCorto Plazo
PLANIFICACIÓN DE PROCESOS
Planificador (Planner): Programa del S.O. que determina que proceso tiene que ejecutarse.Activador (Dispatcher) : Programa del SO que carga el programa seleccionado por el planificador en memoria
Formas de planificar del S.O:Largo plazo: Decidir que procesos batch entran a ejecutarseMedio plazo: Añadir procesos a RAM
Finalización del estado de suspendido.Sistemas con swapping.
CORTO PLAZO: DECIDIR QUÉ PROCESO TOMA EL CONTROL DE LA CPU
NOCIONES BÁSICAS DEL CORTO PLAZO
Tipos de planificaciónSin expulsión: El proceso conserva la CPU mientras lo deseeCon expulsión: El S.O. quita la CPU al proceso cada cierto tiempo.
Colas de procesosPor prioridad (niveles)Por tipo
LotesInteractivo
Reparto de la CPU equitativoEficiencia (optimizar uso CPU)Mejorar el tiempo de respuesta
Modo interactivoModo lotes
Cumplir plazos de ejecución en sistemas de tiempo real
OBJETIVOS DE LA PLANIFICACIÓN
INCOMPATIBILIDAD DE OBJETIVOS!
Windows NT Server ≠ Windows 7 Home Edition
COLAS DE PROCESOS
EJEMPLO
BATCH
Implementación de colas de procesos
Implementación con punteros a otros BCPAcceso eficiente
COLAS DE PRIORIDAD
ALGORITMOS DE PLANIFICACIÓNCÍCLICA (Round Robin)
Asignación de CPU rotatoriaSe asigna un tiempo máximo a todos los procesos (time slot )Los procesos se organizan en una cola circular
Un proceso que excede su slot se expulsa y se coloca al final de la cola
SISTEMAS DE TIEMPO COMPARTIDOREPARTO por UID en vez
de por TIEMPO de PROCESAMIENTO
ALGORITMOS DE PLANIFICACIÓN (II)
FIFO (‘first in-first out’)Los procesos se organizan según una cola ‘clásica’. Entran por el final y esperan su turno.Política de planificación SIN EXPULSIÓNEl proceso en ejecución sólo será expulsado cuando él mismo realiza una llamada bloqueante al sistema (i.e. E/S)Problema: INANICIÓN
Se suele combinar con política de prioridades (i.e. POSIX)
PROCESAMIENTO POR LOTES
ALGORITMOS DE PLANIFICACIÓN (III)
PrioridadesFijas: Problema de inanición (p. ej. RTOS)Variables (aumentan con envejecimiento)
El trabajo más corto primeroAplicación en sistemas BatchMenor tiempo de respuestaPenaliza las tareas largasDificultad en conocer ‘a priori’ las tareas de mayor duración.
Aleatorio
ALGORITMOS DE PLANIFICACIÓN RT (IV)
Definición Sistemas de Tiempo Real (RTOS)Sistemas donde los procesos deben ejecutarse en instantes predeterminados
Tipos de RTSRequisitos blandos / durosEjecución a plazo fijo / periódico
2h:30m:10s
2h:30m:10s 2h:30m:20s
PrioridadReloj de tiempo
9-2-2006 / 2h:30m:15s
La CAPACIDAD DE PROCESAMIENTO NO es especialmente altaPREPROCESAMIENTO PREDECIBLE: Sin caches, sin
paginación, sin predicción de saltos
REQUISITOS DUROS: En ningún caso de puede rebasar el tiempo de reloj asociado al proceso
EJEMPLOS
QNX
RTLinux
VxWorks
Windows CE
PLANIFICACIÓN EN POSIX
PrioridadAbsoluta (RT)
(0)-normal | (>0)-RTDinámica
POSIX 19 a -20 (mayor número menor prioridad)
El planificador siempre elige aquellos procesos con mayor prioridad
Políticas de planificaciónFIFO (procesamiento por lotes)Cíclica (modo interactivo)Otra
Ejercicio: Procesos distribuidos (I)Algunos servicios POSIX para prioridad dinámica
int setpriotiy (PRIO_PROCESS, int pid, int niceval) RETURN VALUE: -1 ERROR, 0 OK
int getpriority (PRIO_PROCESS, int pid)
Escriba un programa en C para POSIXque lance dos tareas P1 y P2 quecompartan escritura en un fichero de texto“log.txt”.
Modifique la prioridad de P1 y P2 ycompruebe como afecta a la salida.
#include <sys/wait.h>
Soluciónint main(void){
pid_t pid, pid2;ofstream f("log.txt", ios::app); //fichero compartidopid=fork();if(pid==0){
sleep(1);cout<<"Proc 1: "<<getpriority(PRIO_PROCESS,pid)<<endl;//…escribir en ficheroexit(EXIT_SUCCESS);
}pid2=fork();if(pid2==0){
sleep(1);cout<<"Proc 2: "<<getpriority(PRIO_PROCESS,pid)<<endl; //…escribir en ficheroexit(EXIT_SUCCESS);
}setpriority(PRIO_PROCESS,pid,19);setpriority(PRIO_PROCESS,pid2,0);int status;while(wait(&status)!=-1) continue;f.close();
execlp("gedit", "gedit", "log.txt", NULL); //opcionalexit (EXIT_SUCCESS);}
PLANIFICACIÓN WINDOWS NT
FIN DE POLÍTICAS DE PLANIFICACIÓN
THREAD (Proceso ligero)
DefiniciónUn thread es un proceso que comparte un espacio en memoria con otros threads.
Estructura de un proceso en WIN NT
COMPARTEN MEMORIA
¡Si termina el hilo principal mueren el resto de hilos!
Paralelización con procesos ligeros
PROGRAMACIÓN CON THREADSUn thread es equiparable a una función que se ejecuta en PARALELO con otras funciones (threads)
Programación con hilosElevada dificultadAl escribir código es fundamental tener en cuenta un PARALELISMO REAL (aun cuando se tenga un solo procesador)Imaginar LLAMADAS DISTINTAS AL MISMO CÓDIGO
Comunicación entre hilos Variables compartidas en memoriaDescriptores de recursos compartidos,Elementos de sincronización compartidos etc.
Aumenta la velocidad de ejecución de tareas con E/S
APLICACIÓN: DISEÑO DE SERVIDORES
Tres arquitecturas de servidor
GESTIÓN DE PROCESOS LIGEROS
JOINING es uno de los mecanismos de sincronización de hilos
SERVICIOS POSIX PARA PROCESOS LIGEROS (I)
int pthread_create (pthread_t* , const pthread_attr_t*, void* (*func)(void*), void* arg )
Crea un proceso ligero que ejecuta func con argumentos arg y atributos attrAtributos (modificables mediante servicios)
Tamaño de la pilaPrioridad, Política de planificación etc.
RETURN VALUE: 0-OK o ERRNUM
void pthread_exit (void* value)Finaliza la ejecución e indica el estado de terminación
pthread_t pthread_self (void)Devuelve el identificador del thread que realiza la llamada
¿COMPARATIVA CON EXIT PARA PROCESOS?
SERVICIOS POSIX PARA PROCESOS LIGEROS (II)
int pthread_join (pthread_t tid, void ** value_ptr)Suspende la ejecución de un thread JOINABLE hasta que termina el thread (a no ser que haya terminado)Devuelve el estado de terminación del thread en value_ptrsegún devuelto por pthread_exit o PTHREAD_CANCELED .RETURN VALUE: 0-OK
int pthread_detach (pthread_t pid)Convierte un hilo en DETACHED en tiempo de ejecuciónRETURN VALUE: 0-OK
#include <pthread.h> Linkar con pthread
Ejemplos: Hilos-Creación
int main(void){
pthread_t thid;pthread_create(&thid, NULL, sumar_thread, NULL);
if(pthread_join(thid,NULL)){ //0-OKcout<<“Hilo joinable no terminado adecuadamente”<<endl;
}exit(EXIT_SUCCESS);}
void* sumar_thread (void*){
int a=5;int b=8;cout<<“la suma del hilo es:”<<a+b<<endl;
phtread_exit(NULL);}
Ejemplos: Hilos-Paso de parámetros
struct sSUMANDOS {int a; int b;} ;int main(void){
sSUMANDOS sum; sum.a=10; sum.b=20;pthread_t thid;pthread_create(&thid, NULL, sumar_thread, &sum);
pthread_join(thid,NULL);exit(EXIT_SUCCESS);}
void* sumar_thread (void*param){
sSUMANDOS* p=(sSUMANDOS*) param;cout<<“la suma del hilo es:”<<p a +p b<<endl;
phtread_exit(NULL);}
Ejemplos: Hilos-Comunicación (I)
struct sSUMANDOS {int a; int b;} ;int main(void){
sSUMANDOS sum; sum.a=10; sum.b=20;pthread_t thid;pthread_create(&thid, NULL, sumar_thread, &sum);
pthread_join(thid,NULL);cout<<“Los valores nuevo son:”<<sum.a<“:”<<sum.b<<endl;
exit(EXIT_SUCCESS);}
void* sumar_thread (void*param){
sSUMANDOS* p=(sSUMANDOS*) param;p a=8; p b=10; //…modifica variable en bloque invocante
phtread_exit(NULL);}
Ejemplos: Hilos-Comunicación (II)
struct sSUMANDOS {int a; int b;} ;int main(void){
sSUMANDOS sum; sum.a=10; sum.b=20;pthread_t thid;pthread_create(&thid, NULL, sumar_thread, &sum);
void* ret_thread;pthread_join (thid, &ret_thread);sSUMANDOS ret;ret.a=((sSUMANDOS*) ret_thread) a;ret.b=((sSUMANDOS*) ret_thread) b;cout<<“Los valores devueltos son:”<<ret.a<“:”<<ret.b<<endl;
exit(EXIT_SUCCESS);}
void* sumar_thread (void*param){
sSUMANDOS* p=(sSUMANDOS*) param;sSUMANDOS* pret=new sSUMANDOS;pret->a=p a*2; pret->b=p b*2; //mod. de valores
phtread_exit(pret);}
Ejemplos: Hilos-Comunicación (III)
struct sSUMANDOS {int a; int b;} ;int suma=0; //variable compartida en memoriaint main(void){
sSUMANDOS sum; sum.a=10; sum.b=20;pthread_t thid;pthread_create(&thid, NULL, sumar_thread, &sum);
pthread_join(NULL);cout<<“La suma es:”<<suma<<endl;
exit(EXIT_SUCCESS);}
void* sumar_thread (void*param){
sSUMANDOS* p=(sSUMANDOS*) param;suma=p a + p b;
phtread_exit(NULL);}
Ejemplos: Hilos-DETACHED
int main(void){
pthread_t thid;pthread_create(&thid, NULL, sumar_thread, NULL);
pthread_detach (thid);pthread_join(NULL);cout<<“hilo principal terminado”<<endl;
exit(EXIT_SUCCESS);}
void* sumar_thread (void*param){
sleep(10);cout<<“hilo terminado”<<endl;
phtread_exit(NULL);}
SERVICIOS POSIX PARA PROCESOS LIGEROS (III)
int pthread_attr_init (pthread_attr_t* attr)Inicializa la estructura de atributos de un thread a sus valorespor defecto previstos por el S.O.RETURN VALUE: 0-OK
int pthread_attr_setdetachstate (pthread_attr_t* attr, intdetachstate)
Establece la forma de terminar de un proceso ligeroSi detachstate = PTHREAD_CREATE_DETACHED el proceso ligero libera sus recursos cuando finalice su ejecuciónSi detachstate = PTHREAD_CREATE_JOINABLE no se liberan los recursos. Hay que utilizar pthread_join(…)En el caso general los hilos deberían ser generados como joinable (recomendado en el standard de POSIX)RETURN VALUE: 0-OK
Por defecto
SERVICIOS POSIX PARA PROCESOS LIGEROS (IV)
int pthread_attr_setschedpolicy(pthread_attr_t* attr, intschedpol)
Establece la política de planificación de un proceso ligeroTiene que tener la proiedad de PTHREAD_EXPLICIT_SCHEDSi schedpol = SCHED_FIFO: política FIFOSi schedpol = SCHED_RR : política ROUND ROBIN
int pthread_attr_setinheritsched (pthread_attr_t* attr, intinheritsched)
Establece la política de planificación en relación con el padreSi inheritsched = PTHREAD_EXPLICIT_SCHED se permite que tenga una política de planificación diferente a la del padreSi inheritsched = PTHREAD_INHERIT_SCHED se hereda la política de planificación del padre
Por defecto
Por defecto
EJEMPLO JERARQUÍA DE THREADS (I)
LIBRERÍA
THREAD
ATRIBUTOS
EJEMPLO THREADS (II)
ATRIBUTO DETACHED
ESPERA A TERMINACIÓN DE HIJOS
¿PASO DE PARÁMETROS?
FIN DE SERVICIOS POSIX PARA HILOS