Entonces, ¿sobre qué base debo decidir si debo usar pthread_self orgettid para determinar qué subproceso está ejecutando la función?
Siempre debe usar pthread_self() cada vez que desee identificar un hilo dentro de su aplicación. gettid() puede ser utilizado para ciertos fines y si sabes que es Linux. Por ejemplo, gettid() se puede usar para obtener semilla para una semilla específica de hilo (usado en srand() ).
Ambos no son portátiles.
Esto no es enteramente verdad. gettid() no es portátil ya que es una función específica de Linux. Pero pthread_self() es portátil siempre que no haga suposiciones sobre su representación.
Por ejemplo, lo siguiente es no portátil.
printf("Thread ID is: %ld", (long) pthread_self());
ya que no hay garantía de que lo que sea pthread_self() va a ser un número entero de algún tipo. Pero
pthread_t my_tid; //filled elsewhere
pthread_t tid = pthread_self();
if( pthread_equal(my_tid, tid) ) {
/* do stuff */
}
es totalmente portátil.
El primero no es portátil porque asume ese id de subproceso es un número entero, mientras que el último no lo es.
¿Por qué hay dos funciones diferentes para obtener la identificación del hilo?
No son dos formas diferentes de obtener el mismo valor. Uno (pthread_self() es proporcionado por la biblioteca de subprocesos (pthreads) mientras que el otro (gettid() es una función específica del sistema operativo. Un sistema operativo diferente puede proporcionar una interfaz/llamada de sistema diferente para obtener un ID de subproceso similar a gettid() . Así que no puedes confiar en gettid() en una aplicación portátil.
pthread_self() returns the process-wide unique pthread-id.
gettid() devuelve el identificador de subproceso único de todo el sistema (específico de la implementación de pthread) (en Linux).
the TID(thread id) returned by gettid() is unique inside a process
Sí.
(or inside a program with multiple processes,
Sí.
inside a process, different thread has different thread id.
Sí.
the TID returned by pthread_self() is unique across processes,
No.
different thread has different TID on the same machine at the same time.
Sí en el mismo proceso, No en toda la máquina.
Como gettid() es específico de Linux y, por lo tanto, no es portátil, la única forma de que el sistema identifique ampliamente un pthread es usar su ID de proceso principal (único en todo el sistema) tal como lo devuelve getpid() junto con su pthread (único en todo el proceso) id tal como lo devuelve pthread_self().
Este es un estudio interesante sobre la diferencia entre conceptual terminología y entidades de software reales (que pertenecen a abstracciones de software específicas).
En primer lugar, preste atención a los tipos de estas dos llamadas.
pid_t gettid(void);
pthread_t pthread_self(void);
Uno es pid_t y el otro es pthread_t . Ambos se refieren a una entidad conceptual común llamada thread , pero los diferentes tipos implican que estos son dos software entities diferentes . Son diferentes representaciones de un thread id , y tiene sentido dentro de la abstracción del software que lo incorpora. Entonces, pthread_t tiene sentido solo dentro de la abstracción soportada por el pthread paquete, y pid_t tiene sentido dentro de la abstracción que incorpora este tipo (es decir, llamadas al sistema Linux que tratan en pid_t ).
Debería usar el tipo correcto según el contexto. Usa pthread_t en el contexto que requiere el tipo pthread_t y pid_t en el contexto que requiere pid_t - independientemente del hecho de que puedan referirse al mismo hilo.
Cada uno de estos contextos tiene una sintaxis prescrita para la comparación y la igualdad. pid_t puede ser comparado directamente por el == operador, mientras que pthread_t debe compararse invocando pthread_equal .
La razón de esta representación dual/abstracciones de software es que el pthread library es una biblioteca de subprocesos portátil que se puede implementar en diferentes sistemas operativos. Diferentes implementaciones del pthread biblioteca garantiza que el thread id el tipo siempre será pthread_t . Estos subprocesos pueden asignarse a un sistema operativo específico thread entity cuyo identificador de sistema operativo depende del sistema operativo (por ejemplo, para Linux es pid_t; para Windows es DWORD ).
Entonces, aunque la implementación subyacente puede diferir de un sistema operativo a otro, el código escrito contra el pthread la abstracción sigue siendo portátil entre los sistemas operativos (siempre y cuando se limite al pthread abstracción).