Posix mutex en C

“El uso de mutex es el método para prevenir situaciones de carrera que se usan con mayor frecuencia. Mutex, que se refiere a la exclusión mutua, esencialmente nos da un bloqueo de cerrojo que impide que varios usuarios accedan y modifiquen simultáneamente los datos cruciales. Siempre que múltiples o más procesos empleen el mismo proceso que su medio para terminar su procesamiento, se debe evitar el punto muerto. El tema principal de la discusión actual será utilizar la función Posix Mutex para evitar un punto muerto con diferentes métodos con lenguaje C en Ubuntu 20.04 sistema. Antes de hacer cualquier cosa con sus fragmentos de código, debemos instalar el compilador "GCC"."

Ejemplo 01

Vamos a comenzar nuestra primera ilustración de las funciones de Posix Mutex con los encabezados necesarios. Sin estos encabezados, nuestro script de C no será operativo de la manera en que lo queremos. El primer stdio.H El encabezado es responsable de la utilización de entradas y salidas regulares en el código. El encabezado estándar "stdlib" es responsable del uso suave de las funciones de biblioteca estándar en el fragmento de código. El unistd.H El encabezado es imprescindible encontrar problemas relacionados con unicodos. Aquí viene la biblioteca para utilizar variables y funciones de cadena relacionadas con la cadena en el lenguaje C, I.mi., cadena.H.

Finalmente, la biblioteca es el "Pthread.H "encabezado que es imprescindible cuando desea usar múltiples lectura en sus fragmentos. Esta biblioteca incluye creación de hilos, unión de hilo, bloqueo de hilo, desbloqueo de hilo y muchas otras funciones relacionadas con la lectura múltiple.

#incluir
#incluir
#incluir
#incluir
#incluir

Después de eliminar los encabezados necesarios, vamos a inicializar 2 hilos utilizando el objeto "pthread_t" de la biblioteca del hilo. El valor "t" se utilizará como ID de subproceso en el futuro cercano. Luego, una variable entera "I" se inicializa a 0, y se declaró la variable "C" para contar los hilos. El objeto de bloqueo mutex "ML" se ha generado utilizando el objeto pthread_mutex_t. Aquí viene la función de hilo "t", que va a bloquear y desbloquear el hilo. Para bloquear el hilo de llamadas, estamos usando la función pthread_mutex_lock () usando el bloqueo "ml" al contar el número de subproceso.

Las declaraciones printf () están aquí para contarnos sobre la inicialización y el final de un hilo específico. Dentro de la inicialización y el final, la función de hilo "t" está bloqueada y no puede ser accedida por otros hilos. Al final, la función pthread_mutex_unlock () se usa para desbloquear el hilo específico y dar acceso a otros hilos.

pthread_t t [2];
int i = 0;
int c;
pthread_mutex_lock (& ​​ml);
sin firmar largo i = 0;
c += 1;
printf ("iniciado %d de hilo ... \ n", c);
para (i = 0; i<(0xFFFFFFFF); i++)
;
dormir (5);
printf ("Fined %d hilo ... \ n", c);
dormir (5);
pthread_mutex_unlock (& ​​ml);
regresar nulo;

La función Main () comienza desde la declaración "IF" que ha estado revisando alguna condición. Utiliza la función pthread_mutex_init () pasando su objeto de bloqueo "ml" y valor nulo para inicializar el bloqueo mutex. Si el valor devuelto de la función init () no es igual a 0, la instrucción printf () mostrará que el bloqueo mutex no se inicializó debido a algún problema. Mientras tanto, el bucle while () usa la condición para la variable "i", que debería ser inferior a 2. Si es menos de 2, entonces la función Thread_Create () se llamará pasando la ID de subproceso "t" como puntero y puntero hacia la función de hilo "t". Si el hilo se creó con éxito, devolvería "0" a la variable "E".

En caso de que devuelva otra parte de 0, imprimirá una, yo.mi., Usando la función Strerror e incremento el valor de una variable "I". Esta función es responsable de llamar a la función de subproceso t para dos hilos diferentes. La función pthread_Join () utiliza ID de hilo para unirlos con la función main (), y la función pthread_mutex_destroy () está aquí para destruir el bloqueo después de que todas las funciones se hayan ejecutado. El regreso a un mensaje Main () se mostrará al final de este programa después de las ejecuciones de subprocesos.

int main ()
if (pthread_mutex_init (& ml, null) != 0)
printf ("Error al inicializar el bloqueo mutex ... \ n");
regresar 1;

mientras yo<2)
int e = pthread_create (& t [i], null, & t, null);
if (e != 0)
printf ("Error al crear un hilo: [%s]", Strerror (e));
i ++;

pthread_join (t [0], nulo);
pthread_join (t [1], nulo);
pthread_mutex_destroy (& ml);
printf ("Hola! Estamos de vuelta en el método principal ... \ n ");
regresar 0;

Estamos compilando la prueba.Cile C con el compilador "GCC" y la opción -lpThread para la ejecución de los hilos. La ejecución muestra que el primer hilo obtuvo acceso a la función "t" y bloqueado.

Después de que se liberó el bloqueo del primer hilo, luego se dio acceso a la función T al segundo hilo, y también se bloqueó y se desbloqueó.

Al final, ambos hilos se ejecutaron, y la función Main () recuperó el control.

Ejemplo 02

Aquí viene otra forma de demostrar el uso de Posix Mutex para bloquear y desbloquear los hilos. Dentro de este ejemplo, no requerimos el unistd.H encabezado, así que no lo vamos a usar. Más, todos los encabezados están aquí, que usamos en el ejemplo anterior. El objeto pthread_mutex_t se usa para crear un bloqueo mutex "ml". El método main () comienza inicializando dos hilos, T1 y T2, utilizando el objeto pthread_t. Utiliza la función pthread_create () dos veces para crear subprocesos llamando a las funciones T1 y T2 pasándoles ID de inicialización de hilos como punteros, i.mi., T1 y T2. En la creación de hilos, la función T1 y T2 se ejecutó una tras otra. Cada una de estas funciones se llama función test () pasando 2 valores de cadena como parámetros.

La función de prueba se usa aquí para bloquear y desbloquear hilos específicos que la llaman, yo.mi., T1 y T2. Para bloquear los hilos, se usa la función pthread_mutex_lock (), y para desbloquear, se usa la función pthread_mutex_unlock (), i.mi., Ambos están utilizando el bloqueo mutex "ml". Dentro del proceso de bloqueo y desbloqueo, las declaraciones de printf se usan con un sueño de 5 segundos después de cada. El primer método printf () mostrará el primer argumento pasado a la función de prueba, y el segundo método printf () mostrará el segundo argumento de cadena pasado a la función de prueba.

#incluir
#incluir
#incluir
#incluir
pthread_mutex_t ml;
void* test (char* p, char* q)
pthread_mutex_lock (& ​​ml);
printf ("%s ... \ n", p);
dormir (5);
printf ("%s ... \ n", q);
dormir (5);
pthread_mutex_unlock (& ​​ml);

void* t1 (void* z)
Prueba ("iniciado", "primer hilo");
void* t2 (void* z)
Prueba ("iniciado", "2do hilo");
int main ()
pthread_t t1, t2;
pthread_create (& t1, null, & t1, null);
pthread_create (& t2, null, & t2, null);
while (1)
salida (0);

Al compilar, te mostrará una advertencia, pero puedes ignorarla por un momento.

La ejecución del código compilado muestra que el primer hilo se inició y obtuvo todos los recursos de la función de prueba.

Después de esto, el bloqueo se lanzó y el segundo hilo obtuvo los recursos. Después del segundo hilo, tenemos que salir de la ejecución con fuerza.

Conclusión

El concepto Posix Mutex se explica brevemente para evitar un punto muerto en la programación C. Por lo tanto, hemos empleado las funciones pthread_mutex_lock y pthread_mutex_unlock para realizar eso. Usando estas funciones en nuestros fragmentos de código, hemos asegurado el uso de recursos para un hilo a la vez.