int - ELAI-UPM
Anuncio
Procesos e hilos Pablo San Segundo (C-206) [email protected] 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ón La unidad de procesamiento gestionada por el S.O. Presencia en memoria y tabla BCP ` Registros de la CPU ` ` Contexto Entorno ` ` ` Identificadores de usuario y grupo Identificador de proceso Variables de entorno ` ` ` Usuario Sistema Control (tablas) ` ` ` ` Estado: Bloqueado, ejecución, listo Prioridad: cola de prioridades E/S: Desc. recursos, ,mensajería etc. Presencia en memoria Bloque de Control de Proceso typedef struct bcp { struct bcp *siguiente; struct bcp *anterior; struct bcp *hebra int retardo; palabra marco; palabra pila; palabra marcador; int pri; int estado; struct bcp *todosenl; int mascara; k_ptrmens retenmens procnombre nombre; } bcp; ESTADOS BÁSICOS DE UN PROCESO ` EN EJECUCIÓN ` ` BLOQUEADO ` ` Un proceso por procesador En espera de completar E/S LISTO ` Preparado para pasar al estado de ejecución ENTORNO DEL PROCESO ` Definición ` ` Ubicación ` ` Tabla NOMBRE-VALOR que se pasa al proceso en su creación Imagen en Memoria: típicamente en la pila Valor ` ` Por defecto Mandatos Shell (API S.O.) SHELL PATH=/usr/bin:/home/pss/bin echo $PATH echo $HOME TERM=tty100 HOME=/home/pss SHELL PATH=$PATH:XXX PDW=/home/pss/ingsw CARACTERÍSTICAS DE PROCESOS ` Jerarquías (familias) ` ` Vida ` ` ` ` Procesos hijo, padre, hermano, abuelo etc.. Creación Ejecución Muerte Tipo de ejecución ` ` Batch (lotes) Interactivo INI INI SES INI SES SHELL SHELL PROC 1 PROC 2 USUARIO ` Definición ` ` Autenticación ` ` ` User login (internamente es un número para el S.O.: i.e uid) Contraseña (password) Super-usuario (sudo, su) ` ` Persona autorizada a utilizar el sistema Derechos de administrador Grupo de usuarios ` ` Colectivo de usuarios con los mismos permisos Todo usuario ha de pertenecer a un grupo FIN DE INTRODUCCIÓN Clasificación de los Sistemas Operativos Fundamento del multiproceso ` Definición ` ` Ejecución concurrente real de varios procesos con un solo procesador Bases ` ` Alternancia de los procesos en la CPU durante la fase de E/S Almacenamiento 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/S Aumenta el uso de la CPU Nuevo paradigma de programación ` Principio de ‘modularidad’: Un programa-varios ‘procesos’ GRADO DE MULTIPROGRAMACIÓN ` Definición ` ` Recurso ` ` Número de procesos activos en un instante de tiempo Memoria 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 CODIGO PILA DATOS Se gestionan fuera del BCP. ¿Por qué? ESTADO DEL PROCESO : CONTEXTO ` ` ` ` ` ` Registros generales ` Motorola 68000: A0-A7, D0-D7 Contador de programa (PC) ` Siguiente instrucción a ejecutar Puntero de Pila (“Call Stack pointer”) ` Referencia la pila en memoria asociado a todo proceso ` Motorola 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 especiales ` Ejemplo: RIED: Registro que Identifica el Espacio de Direcciones que ocupa en memoria el proceso en ejecución PROCESO EN MEMORIA Pertenece al BCP Segmentación fija Hoy en día la segmentación es variable Preasignación inicial de zona de swapping TABLAS DEL SISTEMA OPERATIVO ` Tabla de procesos (BCP) ` ` Tabla de Memoria (alias paginado) ` ` Información para la gestión de memoria Tabla de Entrada / Salida ` ` 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) Información relativa a periféricos y a las operaciones E/S Tabla de Ficheros ` Información sobre los ficheros utilizados por los procesos Ejemplo Tabla de Ficheros Doble direccionamiento Puntero de posición COMPARTEN LECTURA Y ESCRITURA EN FICHERO TABLA DE FICHEROS EJEMPLO: INFORMACIÓN EN EL BCP TREEPS (LINUX) FIN DE PRESENCIA EN MEMORIA DE UN PROCESO NACIMIENTO DE UN PROCESO Linker Transmisión de ficheros al Motorola 68000 A imagen en memoria e.g. kernel.lib/dll FORMACIÓN DE UN PROCESO SE ACTUALIZA LA PRIMERA VEZ Y EN CADA CAMBIO DE CONTEXTO Tablas S.O. COPIA DE LAS BIBLIOTECAS DEL SISTEMA EN LA IMAGEN DE MEMORIA (kernel.lib) EL EJECUTABLE NO CONTIENE A LAS BIBLIOTECAS DEL SISTEMA FIN DE FORMACIÓN DE UN PROCESO SERVICIOS DE GESTIÓN DE PROCESOS ` ` ` ` ` ` ` Identificación de procesos Entorno de un proceso Creación de procesos Cambio de imagen de un proceso Espera a la terminación de un proceso Finalización de la ejecución de un proceso Información adicional SERVICIO POSIX: fork ` Definición ` pid_t fork (void) : Crea un proceso hijo clonando al padre. Copia no exacta (i.e. señales) SERVICIO POSIX: fork ` Librerías ` ` Retorno ` ` ` ` #include <sys/types.h> Identificador de procesoÆpadre 0 Æhijo -1 si error Descripción ` ` ` Crea un proceso hijo que ejecuta el mismo programa que el padre Se heredan los descriptores (i.e. archivos) Se desactivan las alarmas pendientes Depende de la distribución SERVICIO POSIX: exec ` Definición ` Cambia el programa del proceso Los descriptores abiertos se mantienen EJEMPLO: Servicio fork #include <sys/types.h> #include <iostream> 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; } SERVICIO POSIX: exec ` Declaraciones ` ` ` ` Retorno ` ` int execl (const char* path, const char* arg,…) int execlp(const char* file, const char* arg,…) int execvp(const char* file, const char* arg[]) -1 si error o NO RETORNA Ultimo parámetro NULL Descripción ` ` ` El mismo proceso ejecuta otro programa Los descriptores abiertos permanecen abiertos Las señales toman la acción por defecto #include <unistd.h> EJEMPLO: Servicio execl #include <sys/types.h> #include <unistd.h> #include <iostream> 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; } EJEMPLO: Servicio execv #include <sys/types.h> #include <unistd.h> #include <iostream> 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; } SERVICIO POSIX: int exit (int status) ` ` Definición ` Termina un proceso, devolviendo el parámetro status al proceso padre Declaración ` void exit (int status) ` ` Argumento ` ` EXIT_SUCCESS, EXIT_FAILURE Código de retorno al proceso padre Descripción ` ` ` Finaliza la ejecución del proceso Cierra todos los descriptores Se liberan todos los recursos #include <stdlib.h> SERVICIO POSIX: wait ` Definición ` ` ` WUNTRACED pid_t wait (int* status) WNOHANG pid_t waitpid (int pid, int* status, int options) Retorno ` ` Espera la terminación de un proceso hijo CUALQUIERA Declaración ` ` #include <sys/wait.h> Identificador del proceso hijo, -1 si error Descripción ` ` Permite a un proceso padre esperar hasta que termine un proceso hijo Devuelve el estado del proceso hijo al terminar ` Macros para analizar el estado: WIFEXITED, WEXITSTATUS WIFSIGNALED, WTERMSIG, etc… EJEMPLO : Servicio wait con MACROS int main() { Capturar el error 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); } 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 hijos while ( wait(&status) !=-1 ){;} cout<<"Proceso padre terminado"<<endl; exit(EXIT_SUCCESS); } EJEMPLO: waitpid int 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 bloqueante if(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 #include <sys/types.h> #include <sys/wait.h> int main (int argc, char** argv ) { int i, valor; pid_t pid_1, pid_2; Ejecución desde Terminal <Nombre Ejecutable> 3 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; } ¿JERARQUÍA DE PROCESOS ? A) Figura B) Sin Bloque Ejercicio: Procesos distribuidos (I) Impleméntese un proceso que lance la tarea de leer un grafo en formato DIMACS de un fichero de texto y devuelva su grado en pantalla. El proceso principal debe esperar a la terminación de dicha tarea e indicar si se ha resuelto correctamente. FIN DE SERVICIOS POSIX PARA PROCESOS ESTADOS DE UN PROCESO Planificador Corto Plazo SWAPPING 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 ejecutarse Medio 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ón ` ` ` Sin expulsión: El proceso conserva la CPU mientras lo desee Con expulsión: El S.O. quita la CPU al proceso cada cierto tiempo. Colas de procesos ` ` Por prioridad (niveles) Por tipo ` ` Lotes Interactivo OBJETIVOS DE LA PLANIFICACIÓN ` ` ` ` Reparto de la CPU equitativo Eficiencia (optimizar uso CPU) Mejorar el tiempo de respuesta ` Modo interactivo ` Modo lotes Cumplir plazos de ejecución en sistemas de tiempo real 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 BCP Acceso eficiente COLAS DE PRIORIDAD ALGORITMOS DE PLANIFICACIÓN ` CÍCLICA (Round Robin) ` ` ` Asignación de CPU rotatoria Se 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 REPARTO por UID en vez COMPARTIDO 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ÓN El 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) ` Prioridades ` ` ` El trabajo más corto primero ` ` ` ` ` Fijas: Problema de inanición (p. ej. RTOS) Variables (aumentan con envejecimiento) Aplicación en sistemas Batch Menor tiempo de respuesta Penaliza las tareas largas Dificultad 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 RTS ` ` EJEMPLOS QNX Requisitos blandos / duros Ejecución a plazo fijo / periódico RTLinux VxWorks Windows CE Reloj de tiempo Prioridad 9-2-2006 / 2h:30m:15s 2h:30m:10s 2h:30m:10s 2h:30m:20s REQUISITOS DUROS: En ningún caso de puede rebasar La CAPACIDAD DEreloj PROCESAMIENTO NO es especialmente el tiempo de asociado al proceso PREPROCESAMIENTO PREDECIBLE: Sin caches, sin alta paginación, sin predicción de saltos PLANIFICACIÓN EN POSIX ` Prioridad ` Absoluta (RT) ` ` (0)-normal | (>0)-RT Dinámica ` POSIX 19 a -20 (mayor número Æ menor prioridad) ` El planificador siempre elige aquellos procesos con mayor prioridad ` Políticas de planificación ` FIFO (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 POSIX que lance dos tareas P1 y P2 que compartan escritura en un fichero de texto “log.txt”. Modifique la prioridad de P1 y P2 y compruebe como afecta a la salida. #include <sys/wait.h> Solución int main(void) { pid_t pid, pid2; //fichero compartido ofstream f("log.txt", ios::app); pid=fork(); if(pid==0){ sleep(1); cout<<"Proc 1: "<<getpriority(PRIO_PROCESS,pid)<<endl; //…escribir en fichero exit(EXIT_SUCCESS); } pid2=fork(); if(pid2==0){ sleep(1); cout<<"Proc 2: "<<getpriority(PRIO_PROCESS,pid)<<endl; //…escribir en fichero exit(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); exit (EXIT_SUCCESS); } //opcional PLANIFICACIÓN WINDOWS NT FIN DE POLÍTICAS DE PLANIFICACIÓN THREAD (Proceso ligero) ` Definición ` ` Un thread es un proceso que comparte un espacio en memoria con otros threads. Estructura de un proceso en WIN NT ¡Si termina el hilo principal mueren el resto de hilos! COMPARTEN MEMORIA Paralelización con procesos ligeros PROGRAMACIÓN CON THREADS ` Un thread es equiparable a una función que se ejecuta en PARALELO con otras funciones (threads) ` Programación con hilos ` ` ` ` Comunicación entre hilos ` ` ` ` Elevada dificultad Al 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 Variables compartidas en memoria Descriptores 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 attr Atributos (modificables mediante servicios) ` ` ` ` RETURN VALUE: 0-OK o ERRNUM ¿COMPARATIVA CON EXIT PARA PROCESOS? void pthread_exit (void* value) ` ` Tamaño de la pila Prioridad, Política de planificación etc. 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 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_ptr segú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ón RETURN VALUE: 0-OK #include <pthread.h> Linkar con pthread Ejemplos: Hilos-Creación void* sumar_thread (void*) { int a=5; int b=8; cout<<“la suma del hilo es:”<<a+b<<endl; phtread_exit(NULL); } int main(void) { pthread_t thid; pthread_create(&thid, NULL, sumar_thread, NULL); //0-OK if(pthread_join(thid,NULL)){ cout<<“Hilo joinable no terminado adecuadamente”<<endl; } exit(EXIT_SUCCESS); } Ejemplos: Hilos-Paso de parámetros void* sumar_thread (void*param) { sSUMANDOS* p=(sSUMANDOS*) param; cout<<“la suma del hilo es:”<<pÆa +pÆb<<endl; phtread_exit(NULL); } 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); } Ejemplos: Hilos-Comunicación (I) void* sumar_thread (void*param) { sSUMANDOS* p=(sSUMANDOS*) param; //…modifica variable en bloque invocante pÆa=8; pÆb=10; phtread_exit(NULL); } 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); } Ejemplos: Hilos-Comunicación (II) 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); } 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); } Ejemplos: Hilos-Comunicación (III) void* sumar_thread (void*param) { sSUMANDOS* p=(sSUMANDOS*) param; suma=pÆa + pÆ b; phtread_exit(NULL); } struct sSUMANDOS {int a; int b;} ; //variable compartida en memoria int suma=0; int 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); } Ejemplos: Hilos-DETACHED void* sumar_thread (void*param) { sleep(10); cout<<“hilo terminado”<<endl; phtread_exit(NULL); } 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); } SERVICIOS POSIX PARA PROCESOS LIGEROS (III) ` int pthread_attr_init (pthread_attr_t* attr) ` ` ` Inicializa la estructura de atributos de un thread a sus valores Por defecto por defecto previstos por el S.O. RETURN VALUE: 0-OK int pthread_attr_setdetachstate (pthread_attr_t* attr, int detachstate) ` ` ` ` ` Establece la forma de terminar de un proceso ligero Si detachstate = PTHREAD_CREATE_DETACHED el proceso ligero libera sus recursos cuando finalice su ejecución Si 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 SERVICIOS POSIX PARA PROCESOS LIGEROS (IV) ` int pthread_attr_setschedpolicy(pthread_attr_t* attr, int schedpol) ` ` ` ` ` Establece la política de planificación de un proceso ligero Tiene que tener la proiedad de PTHREAD_EXPLICIT_SCHED Si schedpol = SCHED_FIFO: política FIFO Si schedpol = SCHED_RR : política ROUND ROBIN Por defecto int pthread_attr_setinheritsched (pthread_attr_t* attr, int inheritsched) ` ` ` Establece la política de planificación en relación con el padre Si inheritsched = PTHREAD_EXPLICIT_SCHED se permite que tenga una política de planificación diferente a la del padre Si inheritsched = PTHREAD_INHERIT_SCHED se hereda la política de planificación del padre Por defecto EJEMPLO JERARQUÍA DE THREADS (I) LIBRERÍA THREAD ATRIBUTOS EJEMPLO THREADS (II) ¿PASO DE PARÁMETROS? ATRIBUTO DETACHED ESPERA A TERMINACIÓN DE HIJOS FIN DE SERVICIOS POSIX PARA HILOS
