Funciones de subprocesos en C/C++

En un sistema operativo Unix/Linux , los lenguajes C/C++ proporcionan la API (interfaz del programa de aplicación) estándar de subprocesos POSIX (pthread) para todas las funciones relacionadas con subprocesos. Nos permite crear múltiples subprocesos para el flujo de procesos concurrentes. Es más efectivo en sistemas multiprocesador o multinúcleo donde los subprocesos se pueden implementar a nivel de kernel para lograr la velocidad de ejecución. Las ganancias también se pueden encontrar en los sistemas de un solo procesador al explotar la latencia en IO u otras funciones del sistema que pueden detener un proceso.

Debemos incluir el archivo de encabezado pthread.h al comienzo del script para usar todas las funciones de la biblioteca pthreads. Para ejecutar el archivo c, tenemos que usar -pthread o -lpthread en la línea de comando mientras compilamos el archivo.

cc -pthread file.c or
cc -lpthread file.c

Las funciones definidas en la biblioteca pthreads incluyen:

1. pthread_create: se utiliza para crear un nuevo hilo

   Sintaxis:

   int pthread_create(pthread_t * thread, 
                      const pthread_attr_t * attr, 
                      void * (*start_routine)(void *), 
                      void *arg);
   

   Parámetros:

   • subproceso: puntero a un valor entero sin signo que devuelve la identificación del subproceso del subproceso creado.
   • attr: puntero a una estructura que se utiliza para definir atributos de subprocesos como el estado separado, la política de programación, la dirección de la pila, etc. Establecer en NULL para los atributos de subprocesos predeterminados.
   • start_routine: puntero a una subrutina que ejecuta el hilo. El tipo de retorno y el tipo de parámetro de la subrutina deben ser de tipo void *. La función tiene un solo atributo, pero si es necesario pasar varios valores a la función, se debe usar una estructura.
   • arg: puntero a void que contiene los argumentos de la función definida en el argumento anterior
2. pthread_exit: utilizado para terminar un hilo

   Sintaxis:

   void pthread_exit(void *retval);
   

   Parámetros: este método acepta un parámetro obligatorio retval que es el puntero a un número entero que almacena el estado de retorno del subproceso terminado. El alcance de esta variable debe ser global para que cualquier subproceso que esté esperando para unirse a este subproceso pueda leer el estado de retorno.

3. pthread_join: se utiliza para esperar la terminación de un hilo.

   Sintaxis:

   int pthread_join(pthread_t th, 
                    void **thread_return);
   

   Parámetro: Este método acepta los siguientes parámetros:

   • th: id de subproceso del subproceso que espera el subproceso actual.
   • thread_return: puntero a la ubicación donde se almacena el estado de salida del hilo mencionado en th.
4. pthread_self: se usa para obtener la identificación del hilo del hilo actual.

   Sintaxis:

   pthread_t pthread_self(void);
   

5. pthread_equal: compara si dos hilos son iguales o no. Si los dos subprocesos son iguales, la función devuelve un valor distinto de cero; de lo contrario, cero.

   Sintaxis:

   int pthread_equal(pthread_t t1, 
                     pthread_t t2);
   

   Parámetros: Este método acepta los siguientes parámetros:

   • t1: la identificación del hilo del primer hilo
   • t2: la identificación del hilo del segundo hilo
6. pthread_cancel: se usa para enviar una solicitud de cancelación a un hilo

   Sintaxis:

   int pthread_cancel(pthread_t thread);
   

   Parámetro: este método acepta un subproceso de parámetro obligatorio que es la identificación del subproceso al que se envía la solicitud de cancelación.

7. pthread_detach: utilizado para separar un hilo. Un subproceso separado no requiere un subproceso para unirse al terminar. Los recursos del subproceso se liberan automáticamente después de terminar si el subproceso se separa.

   Sintaxis:

   int pthread_detach(pthread_t thread);
   

   Parámetro: este método acepta un subproceso de parámetro obligatorio que es la identificación del subproceso del subproceso que se debe desconectar.

Ejemplo: una implementación simple de hilos puede ser la siguiente:

// C program to show thread functions
  
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
  
void* func(void* arg)
{
    // detach the current thread
    // from the calling thread
    pthread_detach(pthread_self());
  
    printf("Inside the thread\n");
  
    // exit the current thread
    pthread_exit(NULL);
}
  
void fun()
{
    pthread_t ptid;
  
    // Creating a new thread
    pthread_create(&ptid, NULL, &func, NULL);
    printf("This line may be printed"
           " before thread terminates\n");
  
    // The following line terminates
    // the thread manually
    // pthread_cancel(ptid);
  
    // Compare the two threads created
    if(pthread_equal(ptid, pthread_self())
        printf("Threads are equal\n");
    else
        printf("Threads are not equal\n");
  
    // Waiting for the created thread to terminate
    pthread_join(ptid, NULL);
  
    printf("This line will be printed"
           " after thread ends\n");
  
    pthread_exit(NULL);
}
  
// Driver code
int main()
{
    fun();
    return 0;
}

Producción:

This line may be printed before thread terminates
Threads are not equal
Inside the thread
This line will be printed after thread ends

Explicación: Aquí se crean dos hilos de ejecución en el código. El orden de las líneas de salida de los dos subprocesos puede intercambiarse según el subproceso procesado anteriormente. El subproceso principal espera en el subproceso recién creado para salir. Por lo tanto, la línea final de la salida se imprime solo después de que sale el nuevo subproceso. Los hilos pueden terminar independientemente uno del otro al no usar la función pthread_join . Si queremos terminar el nuevo hilo manualmente, podemos usar pthread_cancel para hacerlo.

Nota: si usamos exit() en lugar de pthread_exit() para finalizar un hilo, todo el proceso con todos los hilos asociados se terminará incluso si algunos de los hilos aún pueden estar ejecutándose.