programando con hilos posix
Download
Skip this Video
Download Presentation
Programando con Hilos POSIX*

Loading in 2 Seconds...

play fullscreen
1 / 36

Programando con Hilos POSIX* - PowerPoint PPT Presentation


  • 99 Views
  • Uploaded on

Programando con Hilos POSIX*. Intel Software College. Objetivos. Explorar las funciones de la librería Pthreads para crear y sincronizar hilos. ¿Qué son los pthreads?. Estándar POSIX.1c Interfaz en lenguaje C Los hilos existen dentro del mismo proceso Todos los hilos son pares

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Programando con Hilos POSIX*' - randall-rosario


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
programando con hilos posix

Programando con Hilos POSIX*

Intel Software College

objetivos
Objetivos
  • Explorar las funciones de la librería Pthreads para crear y sincronizar hilos

Programming with POSIX* Threads

qu son los pthreads
¿Qué son los pthreads?
  • Estándar POSIX.1c
  • Interfaz en lenguaje C
  • Los hilos existen dentro del mismo proceso
  • Todos los hilos son pares
    • No es un modelo explícito padre-hijo
    • Excepto: “main thread” contiene toda la información del proceso

Programming with POSIX* Threads

pthread create
pthread_create
  • int pthread_create(tid, attr, function, arg);

pthread_t *tid

    • descriptor del hilo creado

const pthread_attr_t *attr

    • atributos del hilo a crearse

void *(*function)(void *)

    • función que será mapeada al hilo

void *arg

    • argumento que se envía a la función

Programming with POSIX* Threads

pthread create detalles
pthread_create Detalles
  • Inicia un hilo ejecutando la función
  • Descriptor del hilo retornado por medio de la estructura pthread_t
    • Especifica NULL para usar los atributos por default
  • Un solo argumento enviado a la función
    • Si no tiene argumentos, especifica NULL
  • Verificar códigos de error!

EAGAIN – recursos insuficientes para crear el hilo

EINVAL – atributo inválido

Programming with POSIX* Threads

eejemplo creaci n del hilo
#include <stdio.h>

#include <pthread.h>

void *hello (void * arg) {

printf(“Hello Thread\n”);

}

main() {

pthread_t tid;

pthread_create(&tid, NULL, hello, NULL);

}

Eejemplo: Creación del hilo

¿Qué sucede?

Programming with POSIX* Threads

esperando un thread
Esperando un Thread
  • int pthread_join(tid, val_ptr);

pthread_t tid

    • manejador de un hilo a esperar

void **val_ptr

    • valor de salida devuelto por un hilo

Programming with POSIX* Threads

pthread join detalles
pthread_join Detalles
  • Un hilo espera a que un hilo con descriptor tid termine
    • Solo espera a que un hilo se una
    • El hilo debe ser unible
  • Un valor de salida se devuelve del hilo unido
    • Tipo devuelto es (void *)
    • Usar NULL si no se espera un valor de retorno

ESRCH - hilo (pthread_t) no encontrado

EINVAL - hilo (pthread_t) no unible

Programming with POSIX* Threads

estados de un hilo
Estados de un hilo
  • Los hilos Pthread tienen dos estados
    • Unible (joinable)
    • Desacoplado (detached)
  • Por default los hilos son unibles
    • Los recursos se mantienen hasta el pthread_join
    • Pueden ser reseteados con atributos o una llamada API
  • Los hilos desacoplados no pueden unirse
    • Los recursos pueden reclamarse en la terminación
    • No se pueden resetear a ser unibles

Programming with POSIX* Threads

ejemplo m ltiples hilos
#include <stdio.h>

#include <pthread.h>

#define NUM_THREADS 4

void *hello (void *arg) {

printf(“Hello Thread\n”);

}

main() {

pthread_t tid[NUM_THREADS];

for (int i = 0; i < NUM_THREADS; i++)

pthread_create(&tid[i], NULL, hello, NULL);

for (int i = 0; i < NUM_THREADS; i++)

pthread_join(tid[i], NULL);

}

Ejemplo: Múltiples Hilos

Programming with POSIX* Threads

qu falla
¿Qué falla?
  • ¿Qué se muesta de myNum?

void *threadFunc(void *pArg) {

int* p = (int*)pArg;

int myNum = *p;

printf( “Thread number %d\n”, myNum);

}

. . .

// from main():

for (int i = 0; i < numThreads; i++) {

pthread_create(&tid[i], NULL, threadFunc, &i);

}

Programming with POSIX* Threads

slide12

for(int i=0;i<numThreads;i++) {

pthread_create(&tid[i], NULL, thread, (void *) &i);

}

Contenido de la dirección 0x0001004

void *thread(void *pArg)

{

int *p =(int *) arg;

int mynum = *p;

printf(“…….. %d\n",mynum);

pthread_exit(NULL);

}

i=0x0001004

0

1

pArg=0x0001008

0x0001004

1

p=0x000100C

mynum=0x0001010

1

Programming with POSIX* Threads

soluci n almacenamiento local
Solución – Almacenamiento “Local”

void *threadFunc(void *pArg)

{

int myNum = *((int*)pArg);

printf( “Thread number %d\n”, myNum);

}

. . .

// from main():

for (int i = 0; i < numThreads; i++) {

tNum[i] = i;

pthread_create(&tid[i], NULL, threadFunc, &tNum[i]);

}

Programming with POSIX* Threads

pthreads variables mutex
Pthreads Variables Mutex
  • Simple, flexible, y eficiente
  • Permiten estructuras de programación correctas para evitar condiciones de concurso
  • Nuevos tipos
    • pthread_mutex_t
      • Variable mutex
    • pthread_mutexattr_t
      • Atributos de mutex
  • Antes de usar, mutex debe ser inicializada

Programming with POSIX* Threads

pthread mutex init
pthread_mutex_init
  • int pthread_mutex_init( mutex, attr );

pthread_mutex_t *mutex

    • mutex a ser inicializada

const pthread_mutexattr_t *attr

    • atributos a ser establecidos a mutex

ENOMEM – memoria insuficiente para mutex

EAGAIN – recursos insuficientes (otros que no son memoria)

EPERM - no privilegios para ejecutar la operación

Programming with POSIX* Threads

inicializaci n alternativa
Inicialización Alternativa
  • Puede usarse el inicializador estático

PTHREAD_MUTEX_INITIALIZER

    • Usa los atributos por default
  • El programador debe poner atención al alcance de los mutex
    • Deben ser visibles a los hilos

pthread_mutex_t mtx1 = PTHREAD_MUTEX_INITIALIZER;

Programming with POSIX* Threads

pthread mutex lock
pthread_mutex_lock
  • int pthread_mutex_lock( mutex );

pthread_mutex_t *mutex

      • mutex que intenta hacer el lock

Programming with POSIX* Threads

pthread mutex lock detalles
pthread_mutex_lock Detalles
  • Intenta hacer el lock del mutex
    • Si el mutex está bloqueado por otro hilo, el hilo que llama al lock se bloquea
  • Mutex es detenido por el hilo que lo llama hasta que se desbloquea
    • Mutex lock/unlock deben ser pares, si no puede ocurrir un interbloqueo

EINVAL - mutex invalido

EDEADLK – el hilo llamante ya es dueño del mutex

Programming with POSIX* Threads

pthread mutex unlock
pthread_mutex_unlock
  • int pthread_mutex_unlock( mutex );

pthread_mutex_t *mutex

    • mutex a ser desbloqueado

EINVAL - mutex es inválido

EPERM - el hilo llamante no es dueño del mutex

Programming with POSIX* Threads

exjemplo uso del mutex
#define NUMTHREADS 4

pthread_mutex_t gMutex; // ¿porque debe ser global?

int g_sum = 0;

void *threadFunc(void *arg)

{

int mySum = bigComputation();

pthread_mutex_lock( &gMutex );

g_sum += mySum; // los hilos acceden uno a la vez

pthread_mutex_unlock( &gMutex );

}

main() {

pthread_t hThread[NUMTHREADS];

pthread_mutex_init( &gMutex, NULL );

for (int i = 0; i < NUMTHREADS; i++)

pthread_create(&hThread[i],NULL,threadFunc,NULL);

for (int i = 0; i < NUMTHREADS; i++)

pthread_join(hThread[i]);

printf (“Global sum = %f\n”, g_sum);

}

Exjemplo: Uso del mutex

Programming with POSIX* Threads

variables condici n
Variables Condición
  • Los semáforos son condicionales en el contador del semáforo
  • Las variables condición están asociadas con una condición arbitraria
  • Las mismas operaciones: wait y signal
  • Proveen exclusión mutua

Programming with POSIX* Threads

variable condici n y mutex
Variable condición y Mutex
  • Un mutex está asociado con una variable condición
    • Protege la evaluación de la expresión condicional
    • Previene condiciones de concurso entre los hilos que están enviando la señal y los hilos que esperan en la variable condición

Programming with POSIX* Threads

se ales perdidas y falsas
Señales perdidas y falsas
  • Una señal a una variable de condición no se guarda
    • Si no hay un hilo esperando, la señal se pierde
    • Un hilo puede interbloquearse esperando una señal que no será enviada
  • Una variable de condición (rara vez) puede recibir señales falsas
    • Si las señales se hacen predecibles la ejecución es más lenta
    • Se requiere volver a probar la expresión de condición

Programming with POSIX* Threads

algoritmo de variables de condici n

Se niega la condición se necesita proceder

Puede ser opcional

Algoritmo de variables de condición
  • Evita problemas con señales perdidas y señales falsas

adquiere mutex;

while (condición es verdadera)

espera en la variable de condición;

ejecuta región crítica;

actualiza condición;

envía señal a los hilos que esperan;

libera mutex;

El mutex se libera automáticamente cuando el hilo espera

Programming with POSIX* Threads

variables condici n1
Variables Condición
  • pthread_cond_init, pthread_cond_destroy
    • Inicializa/destruye variables de condición
  • pthread_cond_wait
    • El hilo duerme hasta que se efectúa un signal a la variable de condición
  • pthread_cond_signal
    • Señal que libera la variable de condición
  • pthread_cond_broadcast
    • Broadcast que libera la variable de condición

Programming with POSIX* Threads

tipos de variables de condici n
Tipos de variables de condición
  • Tipos de datos usados
    • pthread_cond_t
      • La variable de condición
    • pthread_condattr_t
      • Atributos de la variable de condición
  • Antes de usar, la variable condición (y el mutex) deben inicializarse

Programming with POSIX* Threads

pthread cond init
pthread_cond_init
  • int pthread_cond_init( cond, attr );

pthread_cond_t *cond

    • variable condición a ser inicializada

const pthread_condattr_t *attr

    • attributos a ser establecidos en la variable de conidición

ENOMEM - insuficiente memoria para la variable condición

EAGAIN - insuficientes recursos (diferentes a la memoria)

EBUSY - variable de condición ya inicializada

EINVAL - attr inválido

Programming with POSIX* Threads

inicializaci n alternativa1
Inicialización alternativa
  • Puede usuarse un inicializador estático

PTHREAD_COND_INITIALIZER

    • Usa los atributos por default
  • Los programadores deben estar atentos a la condición y alcance (del mutex)
    • Debe ser visible a los hilos

pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;

Programming with POSIX* Threads

pthread cond wait
pthread_cond_wait
  • int pthread_cond_wait( cond, mutex );

pthread_cond_t *cond

      • Variable condición a esperar

pthread_mutex_t *mutex

      • Debe desbloquearse

Programming with POSIX* Threads

pthread cond wait detalles
pthread_cond_wait Detalles
  • El hilo se bloquea esperando una señal en cond
  • El mutex se desbloquea
    • Permite que otros hilos adquiran el lock
    • Cuando llega una señal, el mutex será readquirido antes de salir del pthread_cond_wait

EINVAL - cond o mutex inválido

EINVAL - mutex diferentes para esperaas concurrentes

EINVAL - el hilo llamante no es dueño del mutex

Programming with POSIX* Threads

pthread cond signal
pthread_cond_signal
  • int pthread_cond_signal( cond );

pthread_cond_t *cond

      • Variable condición a la que se le enviará la señal

Programming with POSIX* Threads

pthread cond signal detalles
pthread_cond_signal Detalles
  • Envía una señal a una variable condición, desbloquea un hilo bloqueado
  • Si no hay hilos esperando, no se toma ninguna acción
    • La señal no se guarda para futuros hilos
  • El hilo que envía la señal no requiere tener el mutex
    • Puede ser más eficiente
    • Puede haber problemas si se usan prioridades de hilos

EINVAL - cond es inválida

Programming with POSIX* Threads

pthread cond broadcast
pthread_cond_broadcast
  • int pthread_cond_broadcast( cond );

pthread_cond_t *cond

      • variable condición a recibir la señal

Programming with POSIX* Threads

pthread cond broadcast detalles
pthread_cond_broadcast detalles
  • Desbloquea todos los hilos que están esperando una variable de condición
  • Si no hay hilos esperando, no se toma ninguna acción
    • Broadcast no se almacena para hilos futuros
  • El hilo que envía la señal no necesita tener el mutex

EINVAL - cond is inválida

Programming with POSIX* Threads

programando con hilos posix temas cubiertos
Programando con hilos POSIX* Temas cubiertos
  • Como crear hilos que hagan trabajo encapsulado dentro de las funciones
  • Coordinar acceso compartido entre hilos para evitar condiciones de concurso

Programming with POSIX* Threads

ad