Posix mutex en C
“Usar mutex es el método más utilizado para prevenir situaciones de carrera. Mutex, que se refiere a la exclusión mutua, esencialmente nos brinda un punto muerto que evita que varios usuarios accedan y modifiquen los datos cruciales al mismo tiempo. Siempre que varios o más procesos utilicen el mismo proceso como medio para completar su procesamiento, se debe evitar un interbloqueo. El tema principal de la discusión de hoy será cómo usar la función Posix Mutex para evitar interbloqueos con diferentes métodos en lenguaje C en el sistema Ubuntu 20.04. Antes de hacer algo con sus fragmentos de código, debemos instalar el compilador «gcc».
Contenidos
ejemplo 01
Comenzamos nuestra primera ilustración de las funciones mutex POSIX con los encabezados requeridos. Sin estos encabezados, nuestro script de C no funcionará de la manera que queremos. El primer encabezado stdio.h es responsable del uso de E/S regulares en el código. El encabezado stdlib estándar es responsable del uso fluido de las funciones de biblioteca estándar en el fragmento de código. El encabezado unistd.h es imprescindible para encontrar problemas relacionados con Unicodes. Aquí viene la biblioteca para usar variables de cadena y funciones relacionadas con cadenas en lenguaje C, es decir, cadena.h. Finalmente, la biblioteca es el encabezado pthread.h, que es imprescindible si desea utilizar subprocesos múltiples en sus fragmentos. Esta biblioteca contiene la creación de subprocesos, la unión de subprocesos, el bloqueo de subprocesos, el desbloqueo de subprocesos y muchas otras funciones relacionadas con subprocesos múltiples. #incluir 
Después de eliminar los encabezados requeridos, inicializaremos 2 subprocesos usando el objeto «pthread_t» de la biblioteca del subproceso. El valor «t» se utilizará como ID de subproceso en un futuro próximo. Luego, una variable entera «I» se inicializa a 0 y la variable «c» se declara para contar los hilos. El objeto de bloqueo mutex «ml» se generó utilizando el objeto pthread_mutex_t. Aquí viene la función de hilo «T» que bloqueará y desbloqueará el hilo. Para bloquear el subproceso que llama, usamos la función pthread_mutex_lock() con el bloqueo «ml» mientras contamos el número del subproceso. Las declaraciones de printf() están aquí para informarnos sobre la inicialización y terminación de un hilo específico. Dentro de la inicialización y terminación, la función de subproceso «T» está bloqueada y no puede ser llamada por otros subprocesos. Al final, la función pthread_mutex_unlock() se usa para desbloquear el hilo específico y otorgar acceso a otros hilos. pthread_t t[2];int i = 0;int c; pthread_mutex_lock(&ml); largo sin signo i = 0; c+ = 1; printf(«%d subproceso iniciado…\n», c); para(i =0; i<(0xFFFFFFFF); i++) ; dormir (5); printf("%d subproceso terminado...\n", c); dormir (5); pthread_mutex_unlock(&ml); devuelve NULL; }
La función main() comienza con la declaración «si» que verificó una condición. Utiliza la función pthread_mutex_init(), pasándole el objeto de bloqueo «ml» y el valor NULL, para inicializar el bloqueo mutex. Si el valor de retorno de la función init() es distinto de cero, la instrucción printf() indica que el bloqueo mutex no se inicializó debido a un problema. Mientras tanto, el bucle While() usa la condición en la variable «I», que debe ser menor que 2. Si es menor que 2, se llama a la función thread_create(), pasando la identificación del hilo «t» como un puntero y un puntero hacia la función del hilo «T». Si el hilo se creó con éxito, devolvería «0» a la variable «E». Si devuelve un valor distinto de 0, generará un ie utilizando la función strerror e incrementará el valor de una variable «I». Esta función es responsable de llamar a la función de subproceso T para dos subprocesos diferentes. La función pthread_join() usa el ID del subproceso para unirlo a la función main(), y la función pthread_mutex_destroy() destruye el bloqueo después de que se hayan ejecutado todas las funciones. Volver a un mensaje principal () se indica al final de este programa después de las ejecuciones del subproceso. int main() { if(pthread_mutex_init(&ml, NULL) != 0) { printf(«No se pudo inicializar el bloqueo mutex…\n»); devolver 1; } while(i<2) { int E = pthread_create(&t[i], NULO, &T, NULO); if(E != 0) printf("No se pudo crear el hilo: [%s]", strerror(E)); i++; } pthread_join(t[0], NULO); pthread_join(t[1], NULO); pthread_mutex_destroy(&ml); printf("¡Hola! Volvemos al método principal..\n"); devuelve 0;}
Compilamos el archivo test.c usando el compilador «gcc» y la opción -lpthread para ejecutar subprocesos. La ejecución muestra que el primer subproceso obtuvo acceso a la función «T» y fue bloqueado.
Después de que el primer subproceso liberó el bloqueo, se otorgó acceso al segundo subproceso a la función T y también se bloqueó y desbloqueó.
Al final, ambos subprocesos se ejecutaron y la función main() recuperó el control.
ejemplo 02
Aquí hay otra forma de demostrar el uso de POSIX mutex para bloquear y desbloquear los subprocesos. En este ejemplo, no necesitamos el encabezado unistd.h, por lo que no lo usaremos. De lo contrario, todos los encabezados que usamos en el ejemplo anterior están aquí. El objeto pthread_mutex_t se utiliza para crear un bloqueo mutex «ml». El método main() comienza inicializando dos hilos, t1 y t2, usando 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 subprocesos como punteros, es decir, t1 y t2. Cuando se creó el hilo, las funciones T1 y T2 se ejecutaron una tras otra. Cada una de estas funciones se denomina función Test() al pasar dos valores de cadena como parámetros. La función de prueba se usa aquí para bloquear y desbloquear subprocesos específicos que lo llaman, es decir, t1 y t2. La función pthread_mutex_lock() se utiliza para bloquear los subprocesos y la función pthread_mutex_unlock() para desbloquearlos, es decir, ambas utilizan el bloqueo mutex «ml». Dentro del proceso de bloqueo y desbloqueo, las sentencias printf se utilizan con 5 segundos de suspensión cada una. El primer método printf() muestra el primer argumento que se pasa a la función Test y el segundo método printf() muestra el segundo argumento de la cadena que se pasa a la función Test. #incluir
Se le presentará una advertencia al compilar, pero puede ignorarla por un momento.
La ejecución del código compilado muestra que el primer subproceso se inició y obtuvo todos los recursos de la función de prueba.
Después de eso, se levantó el bloqueo y el segundo subproceso recibió los recursos. Después del segundo hilo, necesitamos forzar la detención de la ejecución.
Conclusión
El concepto mutex POSIX se explica brevemente para evitar interbloqueos en la programación C. Así que usamos las funciones pthread_mutex_lock y pthread_mutex_unlock para hacer esto. Con estas características en nuestros fragmentos de código, aseguramos el uso de recursos para un subproceso a la vez.
