Compartir
Publicidad

Introducción al multiprocesamiento en C++ IV: sincronización con Mutex

Introducción al multiprocesamiento en C++ IV: sincronización con Mutex
Guardar
0 Comentarios
Publicidad
Publicidad

Después de un breve descanso veraniego, hoy vamos a continuar con la serie introducción al multiprocesamiento en C++. En esta cuarta parte vamos a crear un wrapper alrededor de algunos mecanismos de sincronización.

Más específicamente vamos a crear una clase alrededor de la primitiva de sincronización mutex que ya vimos en el primer artículo de la serie.

Para nuestro wrapper sencillo alrededor de los threads vamos a utilizar solo mutexes por que creo que es lo único que vamos a necesitar.

GThreads con Mutex

Windows tiene una estructura propia llamada mutex pero no vamos a hacer uso de ellos en nuestra clase. Los objetos mutex de Windows pueden ser usados entre procesos y son bastante pesados.

Para nuestro cometido no vamos a necesitar la funcionalidad adicional que ofrece ese tipo de objeto así que vamos a implementar una clase de mutex ligera cuyos objetos puedan ser usados entre diferentes threads pero no entre procesos.

En Windows vamos a utilizar el objeto ligero critical section que es precisamente un mutex que cubre perfectamente nuestras necesidades.

El Mutex

Vamos a crear un nuevo archivo llamado gmutex.h (Genbeta Mutex) y vamos a escribir una sencilla clase que sirva como wrapper alrededor de las estructuras pthreadmutext en Unix y CRITICAL_SECTION en Windows.

Para ello vamos a hacer uso como siempre de la compilación condicional a la que ya estamos acostumbrados, vamos a escribir un prototipo de nuestra clase:

class GMutex {
protected:
    // Tipos de mutex
    #ifdef WIN32
        CRITICAL_SECTION m_mutex;
    #else
        pthread_mutex_t m_mutex;
    #endif
};

El Constructor

En ambas APIs es necesario que el objeto mutex sea iniciado antes de poder utilizarlo, así que vamos a hacerlo en el constructor:

GMutex()
{
    #ifdef WIN32
        InitializeCriticalSection( &mmutex );
    #else
        phtreadmutexinit( &mmutex, 0 );
    #endif
}
El segundo argumento en la función para Unix es supuéstamente un puntero a una estructura de configuración para el mutex pero no es muy necesario. Al pasar el valor 0 los atributos por defecto son aplicados.

Destructor

Ambas APIs requieren de la destrucción del mutex cuando hemos terminado de usarlos. Lo lógico es añadirlo al destructor de la clase:

~GMutex()
{
    #ifdef WIN32
        DeleteCriticalSection( &mmutex );
    #else
        pthreadmutexdestroy( &mmutex );
    #endif
}

Adquirir el Mutex

Adquirir un mutex es una tarea sencilla con ambas APIs:

inline void Lock()
{
    #ifdef WIN32
        EnterCriticalSection( &mmutex );
    #else
        pthreadmutexlock( &mmutex );
    #endif
}

Liberar el Mutex

Liberarlo es igual de sencillo:

inline void Unlock()
{
    #ifdef WIN32
        LeaveCriticalSection( &mmutex );
    #else
        pthreadmutexunlock( &mmutex );
    #endif
}

Código completo

El código completo de la clase es el siguiente:

#ifndef GMutexh_

define GMutexh_

ifdef WIN32

#include <windows.h>

else

#include <pthreads.h>

endif

namespace ThreadLib { class GMutex { public: GMutex() { #ifdef WIN32 InitializeCriticalSection( &mmutex ); #else pthreadmutexinit( &mmutex ); #endif }

    ~GMutex()
    {
        #ifdef WIN32
            DeleteCriticalSection( &m_mutex );
        #else
            pthread_mutex_destroy( &m_mutex );
        #endif
    }

    inline void Lock()
    {
        #ifdef WIN32
            EnterCriticalSection( &m_mutex );
        #else
            pthread_mutex_lock( &m_mutex );
        #endif
    }

    inline void Unlock()
    {
        #ifdef WIN32
            LeaveCriticalSection( &m_mutex );
        #else
            pthread_mutex_unlock( &m_mutex );
        #endif
    }

protected:
    #ifdef WIN32
        CRITICAL_SECTION m_mutex;            
    #else
        pthread_mutex_t m_mutex;
    #endif
}

}

endif // GMutexh_

Como podéis comprobar, nos ha quedado una clase muy sencilla. En el próximo artículo veremos como utilizar esta librería en una demo sencilla.


En Genbeta Dev | Introducción al multiprocesamiento en C++

Temas
Publicidad
Comentarios cerrados
Publicidad
Publicidad
Inicio
Inicio

Ver más artículos