Hilos – Threads con C++

Hilos – Threads con C++

4.1 Definición de un Thread<< figura 4.1 >>

Hilo A

Hilo principal

Hilo BCrea hilo

Crea hilo

Hilos – Threads con C++

4.3.1 Estados de un Thread<< figura 4.4 >>

Hilos – Threads con C++4.5 Modelos de Threads

●El propósito del trabajo con hilos es ejecutar el trabajo en menor cantidad de tiempo. <<Si un trabajo tiene varios hilos, cada uno de éstos ejecuta una

tarea la cuál es parte del trabajo principal>>●El trabajo es delegado a los hilos conforme a cierta estrategia. Si la aplicación modela algunos procedimientos o entidades, entonces se refleja un tipo de modelo. Algunos casos de modelos son:

●Delegados (delegation)●Punto a punto (peer to peer)●Lineal (pipeline)●Productor-Consumidor (Producer-Consumer)

●Cada uno de estos tiene un tipo especifico de WBS, como se verá a continuación.

Hilos – Threads con C++Modelo de Delegados

● Un hilo central o maestro crea otros hilos esclavos, asignándole a cada esclavo una tarea.

● El hilo maestro deberá esperar a que cada esclavo termine su tarea.

Hilos – Threads con C++Modelo Punto a Punto

● Todos los hilos tienen un mismo nivel de asignación de trabajo

● Los hilos son llamados puntuales

● Un hilo puntual crea los otros hilos, necesarios para ejecutar las tareas, pero sin delegación de responsabilidades

● Los hilos puntuales pueden procesar requerimientos de entradas simples compartidas con los otros hilos o cada hilo puede tener su propia entrada de datos

Hilos – Threads con C++Modelo Lineal (Pipeline)

● El modelo lineal se caracteriza por ser una ejecución en serie, fragmentando etapas de ejecución

● En la medida en que cada etapa se termina, se van terminando las tareas● Esta técnica permita varias entradas de datos que se procesan

simultáneamente● Cada hilo es responsable de producir sus propios resultados y hacerlos

disponibles para la siguiente etapa de ejecución● La última etapa genera el resultado final del proceso

Hilos – Threads con C++Modelo Productor – Consumidor

● Hay un hilo productor y hay un hilo consumidor

● El hilo producto genera datos que serán utilizados por el hilo consumidor● Los datos se almacenan en bloques de memoria compartida entre el productor y el consumidor● Este tipo de procesos requiere sincronización ya que si el consumidor utiliza los datos mas

rápido que el productor, entonces el consumidor se tendría que estar deteniendo● Si el productor genera datos mas rápido que la utilización del consumidor, se podrían generar

sobreescritura de buffers de memoria

● Este modelo también es conocido como Cliente-Servidor

Hilos – Threads con C++4.6 Modulo de Librería para Threads POSIX

<<cap. 4.6>>

●La librería de PTHREADS provee el API para crear y administrar los hilos de una aplicación●La librería PTHREADS esta basada en una interface estándar de programación ●La interface de PTHREADS ha sido especificada por el comité de estándares de IEEE llamado Estándar POSIX 1003.1c●La librería de PTHREADS contiene alrededor de 60 funciones categorizadas en:

●Funciones de administración, ●Funciones de MUTEX y ●Funciones de variables condicionadas

●Existen otras librerías para manejo de hilos, sin embargo el de mayor reconocimiento es el de POSIX, mismo que utilizaremos en este curso

Hilos – Threads con C++4.7 Anatomía de un Thread simple

<<ejemplo 4.1>>

Este código muestra como desde un hilo principal (main) se construyen dos hilos A y B, se mandan ejecutar y se espera a que terminen ambos posteriormente. (caso 0 Hughes)#include <iostream> #include <pthread.h> void *task1(void *X) //define task to be executed by ThreadA { cout << "Thread A complete" << endl; } void *task2(void *X) //define task to be executed by ThreadB { cout << "Thread B complete" << endl; } int main(int argc, char *argv[]) { pthread_t ThreadA,ThreadB; // declare threads pthread_create(&ThreadA,NULL,task1,NULL); // create threads pthread_create(&ThreadB,NULL,task2,NULL); // additional processing pthread_join(ThreadA,NULL); // wait for threads pthread_join(ThreadB,NULL); return(0); }

Hilos – Threads con C++4.7 Anatomía de un Thread simple

<<figura 4.11>>Figura que muestra el control de los hilos

<<caso 0.1 Hughes>>En este código se muestra como se puede mandar un parámetro y se resuelve el problema de los mensajes divididos por la dinámica misma de los hilos.

Hilos – Threads con C++Creando hilos (Threads):

Inicialmente main() es un hilo definido por default. Otros hilos requeridos deberán ser definidos en forma explicita

●El comando pthread_create crea un nuevo hilo y lo deja como ejecutable. ●Los argumentos de pthread_create son:

● thread: identificador único para el nuevo hilo● attr: atributo que puede ser usado para fijar las condiciones del hilo. Se puede especificar el atributo o NULL para valores default

● start_routine: especifica el método que se ejecutará, asociado al hilo● arg: Es el argumento que se le pasa al método. Este argumento puede ser

NULL o un tipo de dato de referencia void

●P.ej.: ● pthread_t ThreadA,ThreadB; ● pthread_create(&ThreadA,NULL,task1,NULL); // crea hilo con defaults● pthread_create(&ThreadB,NULL,task2, (void *)t); //crea hilo con parametro

Hilos – Threads con C++El siguiente ejemplo (caso 1 tutorial dev) muestra como se pueden crear varios hilos. Cada hilo envía un mensaje y termina.#include <iostream>

#include <string>

#include <pthread.h>

#define NUM_THREADS 5 // se define el numero de hilos

using namespace std;

//con este metodo se imprime

void *PrintHello(void *threadnum) {

int tid = (int)threadnum; //<-- se cacha el parámetro

cout <<"\neste es el hilo: \t"<< tid;

pthread_exit(NULL); //<-- se mata el hilo

}

int main (int argc, char *argv[]) {

pthread_t threads[NUM_THREADS]; //<- se crea un arreglo

int rc;

int t;

for(t=0; t<NUM_THREADS; t++){

cout << "\ndesde main se va a crear el hilo: " << t;

rc = pthread_create(&threads[t], NULL, PrintHello, (void *)t);

if (rc){ //← se cacha en rc un código de retorno

cout <<"ERROR; return code from pthread_create() is\t" << rc;

exit(-1);

}

}

system("pause");

pthread_exit(NULL);

}

Hilos – Threads con C++Atributos de un Thread●Por default un Thread es creado con ciertos atributos. Estos pueden ser cambiados por medio del objeto de atributos.

●Los objetos pthread_attr_init y pthread_attr_destroy se utilizan para iniciar y destruir el objeto atributo. ●El caso 2 tutorial Dev muestra esto.● ¿Qué significa que un thread sea joinable o que sea detached? (ver 5.3 del tutorial)

●Se cuenta con otras rutinas para fijar mas atributos.

Terminación de un Thread:●Una forma sencilla de terminar un Thread es que regrese a main.

●Otra forma es llamando al método pthread_exit(), ya sea de manera individual (por c/thread) o desde main, en cuyo caso se terminan todos los threads que dependían de main.

●Otra forma es con pthread_cancel(pthread_t thread). Esta no es una forma habitual de dar por terminado un Thread, por lo que no se recomienda su uso. El siguiente código muestra el proceso de cancelación de Threads.

Hilos – Threads con C++int main(int argc, char *argv[]) { pthread_t Threads[3];void *Status; pthread_create(&(Threads[0]),NULL,task1,NULL); pthread_create(&(Threads[1]),NULL,task2,NULL); pthread_create(&(Threads[2]),NULL,task3,NULL);

pthread_cancel(Threads[0]); pthread_cancel(Threads[1]); pthread_cancel(Threads[2]);

for(int Count = 0;Count < 3;Count++) { pthread_join(Threads[Count],&Status); if(Status == PTHREAD_CANCELED){

cout << "thread" << Count << " has been canceled" << endl; } else{

cout << "thread" << Count << " has survived" << endl; }

} return(0); }

// desarrollar y probar para demostrar, complementando task1, 2 y 3.

Hilos – Threads con C++El API de PThreads ofrece 3 tipos de clases de métodos:

Administración de Hilos: Esta clase tiene las capacidades de crear, ligar,

desligar y reunir hilos.

Mutexes: Esta clase se encarga de la sincronización de los

hilos. Su significado real es “mutual exclusion”. Mutex puede crear, destruir, bloquear y desbloquear hilos.

Variables condicionantes: Esta tercera clase tiene que ver con la comunicación

entre hilos. Esta clase incluye funciones que pueden crear, destruir, esperar o señalizar mediante variables de los hilos.

MutexMutex es una abreviación de "mutual exclusion".

● Una variable MUTEX puede ser sujeto de actualización por dos hilos simultaneamente y el resultado de esta doble actualización generaría condiciones resultantes erroneas.

● MUTEX implementa un sistema de protección a las variables que son sujeto de actualización por múltiples hilos.

● Una variable MUTEX quedará bloqueda durante un proceso A y el proceso B tendrá que esperar a que se libere la variable, garantizando así la validez de la actualización.

Sea el siguiente ejemplo de una actualización de un saldo:

Hilo A Hilo BSaldo = 1000Saldo += 200 Saldo = 1000

Saldo+= 200Saldo = 1200

Saldo = 1200

● En realidad el resultado de estas operaciones debería de ser 1400, pero dado que cada hilo operó en forma independiente, ambos resultados son erroneos.

MUTEX

● Actividad :● Investigar la forma de generar una variable

MUTEX con PTHREADS, demostrar funcionamiento

● Se recomienda la consulta de la páginahttps://computing.llnl.

gov/tutorials/pthreads/#Abstract

MUTEXMutex tiene dos operaciones basicas: lock and unlock.

● Si un mutex está unlocked y un hilo intenta un lock, el hilo hace lock y continua.● Si un mutex está locked y otro hilo intenta un lock, el segundo hilo se espera hasta que se libere el

recurso.

Las 5 operaciones basicas de mutex son:

● Int pthread_mutex_init (pthread_mutex_t *mut, const pthread_mutexattr_t *attr); → inicializa y el segundo parámetro podría ser NULL

● Int pthread_mutex_lock (pthread_mutex_t *mut); →Locks ● Int pthread_mutex_unlock (pthread_mutex_t *mut); →Unlocks ● Int pthread_mutex_trylock (pthread_mutex_t *mut); → adquiere el lock o devuelve EBUSY. ● Int pthread_mutex_destroy (pthread_mutex_t *mut); → libera la memoria y cualquier recurso

involucrado con mutex● EjemploTHREAD 1 THREAD 2pthread_mutex_lock (&mut);

pthread_mutex_lock (&mut); a = data; /* blocked */a++; /* blocked */data = a; /* blocked */pthread_mutex_unlock (&mut); /* blocked */

b = data;b--;data = b;pthread_mutex_unlock (&mut);

Ver ejemplo en: https://computing.llnl.gov/tutorials/pthreads/#Abstract

MUTEXDesarrollar el siguiente caso:

1. Se ha definido un arreglo de 5 elementos, de los cuáles cada posición representa el saldo de las operaciones del lunes, martes, …. , viernes

2. Declarar un primer hilo que todo el tiempo esta actualizando los saldos mediante un sistema de cin/cout. Cada que va a actualizar un elemento del arreglo le hace un lock() y despues lo libera.

3. Habrá un segundo hilo que cada 5 segundos recorre el arreglo y muestra el saldo (suma de los 5 elementos), cosniderando que si hay un elemento bloqueado, deberá esperar o reintentar.

4. Proponer una opción de salida del programa que cierra todos los hilos y muestra el saldo final

Premisas para proyecto Final● Lenguajes de programación Concurrente: ● Ada …. (Historia, características, usos y aplicaciones)● Occam….● Linda ….● Java● C#● C/C++ (?)● Pascal● ● Algoritmos y Problemas:

● Comida de los filósofos (Dijkstra)● Multiplicación de matrices● Problema de los fumadores● Ordenamiento de datos con concurrencia

● Algoritmo de Dekker (Exclusión mutua)● Algoritmo de Peterson (Exclusión mutua)● Algoritmo de los semáforos (Dijkstra Exclusión mutua)

Premisas para proyecto Final● Lenguajes de programación Concurrente: ● Ada …. (Historia, características, usos y aplicaciones)● Occam….● Linda ….● Java● C#● C/C++ (?)● Pascal● ● Algoritmos y Problemas:

● Comida de los filósofos (Dijkstra)● Multiplicación de matrices● Problema de los fumadores● Ordenamiento de datos con concurrencia

● Algoritmo de Dekker (Exclusión mutua)● Algoritmo de Peterson (Exclusión mutua)● Algoritmo de los semáforos (Dijkstra Exclusión mutua)