THREADS Materia: Técnicas Digitales 3 1Autor: Jonathan Rubstein.

THREADSMateria: Técnicas Digitales 3

1Autor: Jonathan Rubstein

ÍndiceÍndiceProcesosCiclo de vidaSchedulingSincronizaciónSeñalesAtributosFuncionesEjemplos

Autor: Jonathan Rubstein 2

Procesos – DefinicionesProcesos – DefinicionesProcesos pesados:

Procesos livianos:


Los procesos no comparten ninguna porción de la memoria entre si. Cada uno se ejecuta en su propio procesador virtual con CPU y memoria. Todos ellos comparten el mismo espacio de almacenamiento permanente (el disco).

Necesita una MMU para su uso.

Los procesos livianos comparten la memoria pero tienen su propia CPUvirtual.

Procesos – Procesos Procesos – Procesos livianoslivianosSe pueden tener varios en una

misma área de memoria.El tiempo de creación es 10 a 100

veces menor comparado con la creación de procesos pesados.

Se destruyen con mayor rapidez.El context switch es más rápido.Se comunican entre si con mayor

facilidad.Reducen la seguridad.


Procesos - estructurasProcesos - estructurasCada tipo de proceso tiene su propia estructura de datos,

en la cual guarda la información necesaria para su control.

PCB ( process control block ) o task_struct pid y ppid. Prioridad. Dirección al proximo pcb. Stacks y Registros. Estados del proceso. Datos para ipc. File descriptors varios. Restricciones y permisos.

TCB ( Thread control block ) Thread id. Prioridad. Estado. Registros de CPU. Stack pointer. Program counter. Signal mask


Ciclo de vidaCiclo de vida Just create: Se instancia el thread pero todavía esta activo. Runnable: El thread esta esperando a que el scheduler le

de su slot correspondiente. Running: El thread se esta ejecutando. Blocked: Se esta ejecutando una función bloqueante, ya

sea operaciones de E/S o métodos de sincronización.

Dead: Termino su función o surgió un error que para el

thread.


SchedulingScheduling Cada thread tiene su juego de parámetros para el

scheduler. Puede ser cargados antes o después de su creación.

La política utilizada para cuando se bloquea la ejecución por un mecanismo de sincronización se define cuando se crea dicho mecanismo.

Para definir los quantum de tiempo se tienen en cuenta la prioridad, el estado y la métrica entre otras variables.

La métrica refiere al comportamiento del thread. Por ejemplo, estaba esperando un evento que acaba de llegar.

En cuanto al context switch, los procesos livianos tiene menor tiempo de cambio debido a que se guardan menos datos.

Se introduce la función yield() que fuerza el cambio de contexto.


Sincronización – El porqueSincronización – El porqueLos procesos livianos comparten

todo su acceso a memoria por lo tanto se crean race condition constantemente.

Al igual que los semáforos en ipc se debe prevenir la escritura y lectura recurrente.

Se puede bloquear un thread hasta que se de una condición especifica.


Sincronización – Sincronización – MecanismosMecanismosMutex ( Mutual exclusion lock )Similar al semaforo de ipc. Bloquea el flujo hasta que es

liberado.

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

JoinEspera a que termine un thread especifico.

condition variablesBloquean un thread hasta que otro cumple la condición.

Puede despertar a un thread que este esperando o a todos aquellos que esten bloqueados por la condicion.

pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER


Sincronización - Sincronización - DeadLocksDeadLocks Mutex

void *function1(){… pthread_mutex_lock(&lock1); - Execution step 1

pthread_mutex_lock(&lock2); - Execution step 3 DEADLOCK!!!

... pthread_mutex_lock(&lock2);

pthread_mutex_lock(&lock1); } void *function2() { ...

pthread_mutex_lock(&lock2); - Execution step 2pthread_mutex_lock(&lock1); ...

pthread_mutex_lock(&lock1);pthread_mutex_lock(&lock2); ... }

main() { ... pthread_create(&thread1, NULL, function1, NULL); pthread_create(&thread2, NULL, function1, NULL); ... }


Señales Señales Se configura que señal puede recibir cada thread. int pthread_sigmask(int how, const sigset_t *newmask, sigset_t *old- mask);Posibilidades:

SIG_SETMASK,SIG_BLOCK,

SIG_UNBLOCK

Se puede enviar una señal especifica a un thread en particular.int pthread_kill(pthread_t thread, int signo);

Es posible bloquear un thread hasta que llegue una señal activada en el set indicado.

int sigwait(const sigset_t *set, int *sig);

Para cambiar el handler se utiliza: int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);


AtributosAtributosLos atributos son las propiedades.Son del tipo pthread_attr_t.Se les asignan al crear el thread. Si

al lanzarlo los atributos son nulos se le otorga los definidos por defecto.

Definen el estado de espera ( join ), quien lo controla ( scope ),la política para el scheduler, prioridad, entre otros.

Para destruirlos se usa pthread_attr_destroy().


Funciones - 1Funciones - 1 Crea un thread. int pthread_create(pthread_t *tid ,pthread_attr_t *attr,void *(*func)(void*), void

*arg);

Espera por la finalizacion de un thread que no sea detach. int pthread_join(pthread_t tid, void **status)

Configura al thread para liberar los recursos usados al terminar. int pthread_detach(pthread_tic)

Termina la ejecución. void pthread_exit(void *status)

Devuelve el thread id. pthread_t pthread_self(void)


Funciones - 2Funciones - 2 Copia los argumentos por defecto a atributo.

int pthread_attr_init(pthread_attr_t* atributo)

Destruye la varible atributo.

int pthread_attr_destroy(pthread_attr_t * atributo)

Compara dos thread id (devuelve cero si son distintos).

int pthread_equal(pthread_t tid1, pthread_t tid2)

Cancela la ejecucion del thread indicado.

int pthread_cancel(pthread_t tid)


Funciones - 3Funciones - 3 Si el mutex esta libre lo bloquea, sino para la ejecución

hasta que este libre.

int pthread_mutex_lock (pthread_mutex_t *mutex)

Trata de bloquar el mutex, si esta ya esta tomado devuelve un EBUSY.

int pthread_mutex_trylock (pthread_mutex_t *mutex)

Si el thread esta bloqueado lo libera.

int pthread_mutex_unlock (pthread_mutex_t *mutex)

Destruye el mutex.

int pthread_mutex_destroy (pthread_mutex_t *mutex)


Funciones – 4Funciones – 4 Bloquea hasta que se cumple la condición.

int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex)

Despierta a un thread que este dormido por cond_wait.

int pthread_cond_signal (pthread_cond_t *cond)

Despierta a todos los thread dormidos.

int pthread_cond_broadcast (pthread_cond_t *cond)

Destruye a la variable cond.

int pthread_cond_destroy (pthread_cond_t *cond)


THREADS Materia: Técnicas Digitales 3 1Autor: Jonathan Rubstein.

Documents

Transcript of THREADS Materia: Técnicas Digitales 3 1Autor: Jonathan Rubstein.