Sistema de Operación
THREADS
Procesos - Threads
Dos características importantes de proceso
• Es la unidad de recurso a la cual el SO le asigna recursos.
• Es la unidad de despacho .
En los modernos OS estas 2 características son tratadas
independientemente
• unidad de recurso referida como proceso o tarea
• unidad de despacho referida como thread
Procesos - Threads 1) Proceso: (proceso pesado)
– Unidad de propiedad de recursos del proceso
– Tiene muchos atributos
– Es caro de crear, de destruir, de cambiar de contexto, etc.
2) Hilo de ejecución: (proceso ligero, tarea, etc.)
– Actividad concurrente dentro de un proceso pesado
– Pueden existir varios hilos de ejecución en el mismo proceso
– Comparten los recursos del proceso (memoria, ficheros, etc.)
– Tienen pocos atributos (contexto) y son baratos de gestionar
ThreadsUn thread (LWP Light Weight Process) es flujo de ejecución
de un proceso. Es la unidad básica de utilización del CPU y
está constituida por:– PC
– Conjunto de registros
– Espacio para pila
Los threads comparten con otros threads:
-- Código
– Datos
– Archivos abiertos, señales.
Threads
Threads
Multithreading : cuando un OS soporta múltiples threads
dentro de un simple proceso.
Single threading: cuando el OS no reconoce el concepto de
thread.
MS-DOS: un solo proceso, un solo thread
UNIX: múltiples procesos usuarios pero un solo thread por
proceso.
SOLARIS y NT: soportan múltiples threads
Threads
One process
One thread
Multiple processes
One threads per process
One process
multiple threads
multiple processes
multiple threads per process
Threads• Thread tienen estados de ejecución
– running– ready– blocked
• Thread tiene un stack de ejecución.
• El contexto de los threads se salva cuando pierde el
CPU.
• Terminar un proceso acaba con todos los threads
del mismo.
Single and Multi-threaded
PCB
User
Address
Space
User
Stack
Kernel
stack
Single threaded process
model
PCB
User
Address
Spaces
User
Stack
Kernel
Stack
Thread
Control
Block
User
Stack
Kernel
Stack
User
Stack
Kernel
stack
Thread
Control
Block
Thread
Control
Block
thread1 thread2 thread3
Multithreaded Process Model
Single and Multi-threaded
Ventajas thread vs Proceso
• Poco tiempo para crear nuevos threads en un
proceso existente.
• Poco tiempo para terminar threads.
• Poco tiempo para switching entre threads.
Ejemplos de Threads
•Un thread realiza un menú display y lee los datos de
entrada del usuario, mientras que otro thread ejecuta
comandos usuarios.
•Un file server sobre LAN, un thread para cada
requerimiento
Threads• Los threads tienen acceso al espacio de memoria y
recursos del proceso.
Cuando un threads altera un espacio de memoria, todos los otros del
threads del proceso lo ven.
Un archivo abierto por un thread esta disponible a los otros.
Así que los threads se pueden comunicar entre ellos
sin invocar el kernel. Sin embargo es necesario
sincronizar sus actividades para no tener
inconsistencia en la data.
Threads
Todos los threads corren independientemente uno
de otro, en el mismo espacio de direcciones y no son
visibles fuera del proceso.
Si los threads comparten recursos implica que un
cambio de CPU entre threads no es costoso, en
comparación con el cambio de CPU entre procesos.
Principalmente porque no se requiere realizar
trabajos de administración de memoria
Implementación de Threads
• Existen dos grandes categorías para la
implementación de los threads
– User-Level Threads (ULT)
– Kernel-Level Threads (KLT)
U L T
• El manejo de los threads es hecho por la aplicación
mediante el uso de librerías de threads.
• El OS no está conciente de los threads a nivel de
usuario .
• El switching entre Threads no requiere pasar a
modo kernel .
• Si un thread es bloqueado, causará que todo el
proceso se bloquee
Threads a nivel de usuario (ULT)
P
Kernel
Space
User
Space
Threads
Library
User-level threads
Pure User Level
Threads Library
Paquete de rutinas para gerenciar los ULTs
Contiene código para
• Crear y destruir threads
• Pasaje de mensaje y data entre threads.
• Planificación de los threads.
• Salvar y recuperar contexto de threads.
Ventajas de ULT• El switching entre threads no requiere de modos
privilegiados (modo kernel). Es decir, los cambios de
contexto entre los hilos a nivel de usuario son rápidos, ya
que no involucran llamadas al sistema.
• La planificación de los threads se realiza dentro del
proceso. El scheduling puede ser específico a la
aplicación.
• ULTs puede correr sobre cualquier OS. Necesita solo la
libraría de threads.
• El sistema operativo crea sólo un hilo en el núcleo por
cada proceso
Inconvenientes de ULT
• System call en muchos OS son bloqueantes, esto
implica que cuando un thread ejecuta un System call,
tanto el thread como TODOS los threads del proceso
están bloqueados.
• El kernel puede solamente asignar procesos a
procesadores. Dos threads dentro del mismo proceso NO
pueden correr simultáneamente sobre dos procesadores
distintos.
Threads a nivel de kernel (KLT)
• El sistema operativo soporta los threads y proporciona un
conjunto de llamadas al sistema para su manipulación.
• El OS crea un thread kernel por cada thread de usuario.
• El kernel mantiene la información de contexto tanto : de
los procesos como los threads.
• Cambio de contexto entre threads es hecho por el kernel.
• Los threads a nivel de kernel se bloquean y despiertan en
forma independiente.
• El scheduling de los threads es hecho por el kernel.
Threads a nivel de Kernel (KLT)
Kernel
Space
User
Space
User -Level threads
Kernel-level threads
P
Kernel-level threads
Enfoque Combinado
Algunos OS dan la facilidad de los dos esquemas
ULT/KLT. El cual trata de combinar las ventajas de los
puros esquemas (ULT/KLT) mientras minimiza sus
desventajas.
Un ejemplo de ello es SOLARIS.
En un esquema combinado múltiples threads dentro de
una aplicación pueden correr en paralelo sobre múltiples
procesadores y un system call no bloquea el proceso.
Enfoque Combinado
• Creación de threads es hecho en el espacio usuario
• Scheduling y sincronización de threads
mayoritariamente es hecho en el espacio usuario
• Multiples ULTs son mapeados en menos o igual
número de KLTs.
• El programador puede ajustar el número de KLTs
• Combina lo mejor de ambos enfoques,
Como se programan threads?
Dos posibilidades
• Utilizando un lenguaje de programación convencional y llamadas al sistema (o funciones de biblioteca).
– Ejemplo: Hilos POSIX (pthreads) utilizados desde C
• Utilizando construcciones lingüísticas (o clases) de un lenguaje de programación concurrente
– Ejemplo: tareas en Ada95, threads en Java
- En este caso, el compilador traduce las construcciones lingüísticas a:
– Llamadas al sistema (hilos a nivel de núcleo)
– Llamadas a bibliotecas propias de soporte de hilos (hilos a nivel de usuario)
Hilos POSIX1. Existe un hilo (thread) inicial que ejecuta la función main().
2. Este hilo puede crear más hilos para ejecutar otras funciones dentro del espacio de direcciones del proceso
3. Todos los hilos de un proceso se encuentran al mismo nivel
– Esto significa que son “hermanos”, a diferencia de los procesos cuya relación es “padre-hijo”.
4. Los hilos de un proceso comparten las variables y recursos globales (archivos, manejadores de señales, etc.) del proceso
– Además, cada uno tiene una copia privada de sus parámetros iniciales y de las variables locales de la función que ejecuta
Creacion de hilos
Creación de hilos: int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);
donde – attr es el atributo que contiene las características que tendrá el hilo (ver después) – start_routine es la función que ejecutará el hilo – arg es un puntero a los parámetros iniciales del hilo – en thread se devuelve el identificador del hilo creado
Creacion de hilos (cont II)
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);
Esta llamada: – Crea inmediatamente el hilo en estado preparado – Produce que el hilo creado y el creador compitan por la CPU según la política de planificación del sistema – Puede ser invocada por cualquier hilo del proceso (no sólo por el “hilo inicial”) para crear otro hilo
POSIX hilos
Atributos de creación de hilos : int pthread_attr_init(pthread_attr_t *attr); int pthread_attr_destroy(pthread_attr_t *attr);donde – attr es el atributo a ser creado/destruido
Mediante estas llamadas: – Se crea/destruye un atributo de creación de hilos – La función “init” inicializa attr con los valores por defecto Estos valores se pueden modificar con funciones específicas – Se pueden crear múltiples hilos con la misma variable attr
POSIX Hilos
Modificación de atributos de creación de hilos : int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate); int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);donde – detachstate indica si otro hilo podrá esperar a la finalización de este hilo (mediante una instrucción pthread_join): PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_DETACHED
POSIX Hilos
Modificación de atributos de creación de hilos (ii):– Existen otras funciones, pero no se van a describir… int pthread_attr_setscope(pthread_attr_t *attr, int contentionscope); int pthread_attr_getscope(const pthread_attr_t *attr, int *contentionscope); int pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched); int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inheritsched); int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy); int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy); int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param); int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param); ...
POSIX Hilos
Terminación y espera a la terminación de hilos: int pthread_exit(void *exit_status); int pthread_join(pthread_t *thread, void **exit_status);donde – exit_status es un puntero a una variable mediante la cual un hilo que finaliza (pthread_exit) comunica un valor a otro que está esperando su terminación (pthread_join) En POSIX, – un hilo finaliza (voluntariamente) su ejecución cuando: Finaliza la ejecución de las instrucciones de su función, o bien Invoca pthread_exit – la finalización del último hilo de un proceso finaliza el proceso
POSIX Hilos
Identificación de hilos: pthread_t pthread_self(void); int pthread_equal(pthread_t th1, pthread_t th2);donde – pthread_self devuelve el identificador interno del hilo invocante. – puesto que este identificador puede no ser escalar, la función pthread_equal sirve para comparar dos identificadores. Esta función devuelve cero (0) si dos identificadores no son iguales y otro valor si lo son
Identificación de hilos: pthread_t pthread_self(void); int pthread_equal(pthread_t th1, pthread_t th2);donde – pthread_self devuelve el identificador interno del hilo invocante. – puesto que este identificador puede no ser escalar, la función pthread_equal sirve para comparar dos identificadores. Esta función devuelve cero (0) si dos identificadores no son iguales y otro valor si lo son
POSIX Hilos...void *funcion(void *p) { printf(“Soy un hilo feliz!\n”);}...int main( void ) { pthread_t id_hilo; pthread_attr_t atributos; printf(“Hilo principal: principio\n”); pthread_attr_init(&atributos); pthread_create(&id_hilo, &atributos, funcion, NULL); printf(“Hilo principal: He creado un hermano\n”); pthread_join(id_hilo,NULL); printf(“Hilo principal: Acabo!”);}
POSIX Hilos Ejem 1
POSIX Hilos (Ejem 2)
POSIX Hilos (Ejem 2 cont II)
Threads in Unix-Solaristhr_create create thread
thr_join causes the calling thread to wait until target thread is finished
thr_exit destroy calling thread
thr_suspend suspend target thread
thr_continue make suspended thread active
thr_setconcurrency set desired number threads active at the same time to a new parameter
thr_getconcurrency get current concurrency level
thr_setprio set thread relative priority
thr_getprio get relative priority of the thread
thr_yield causes the current thread to yield its execution in favor of another thread with the same or greater priority
thr_kill kill a thread
thr_keycreate allocate a key that locates data specific to each thread in the process
thr_min_stack amount of space needed to execute a null thread
thr_setspecific binds thread-specific value to the key
thr get-specific gets thread-specific value of the key
Threads Synchronization (Posix)
Threads – Sharing options(Linux)
Pid = clone(function, stack_ptr, sharing_flags, arg);
Bits in the sharing_flags bitmap
Windows–NT Processes and Threads
Basic concepts used for CPU and resource management
Processes and Threads
Relationship between jobs, processes, threads, and fibers
InterProcess Communication
Shared Memory – Threads – easiest - The critical Section problem! Non-shared Memory:
File/Pipes Unbuffered messages - Rendezvous Buffered messages – Mailboxes and Sockets Sockets: Address – Domain+Port Sockets: Types – Stream or Datagrams Sockets: API: Socket, Bind, Connect, Read/Write
Top Related