Linux ID de processus et l'ID de thread

Supposons que nous avons à l'utilisateur de nombreux processus en cours d'exécution sur Linux. Chaque processus dispose de nombreux threads en cours d'exécution.

Je peux obtenir l'ID de processus en appelant getpid(), la valeur de retour est un nombre entier.

Je peux obtenir l'ID de thread en appelant pthread_self(), la valeur de retour de ce qui est opaque type appelé pthread_t.

Maintenant, j'ai besoin de stocker l'ID de processus (un int, 4 octets en général) et l'ID de thread (pthread_t, besoin de comprendre combien d'octets) en mémoire partagée, de sorte que je peux l'utiliser plus tard les deux pièces d'identité de l'information pour identifier ce thread spécifique et de vérifier si le fil est toujours en cours d'exécution ou non.

J'ai trouvé beaucoup de sources en ligne cast pthread_t soit unsigned int ou unsigned long. Depuis que je ne veux pas de perte de données lors de la coulée, comment dois-je traiter avec les pthread_t de données de sorte que c'est une taille fixe morceau de données (comme mentionné, j'ai besoin de stocker le fil de l'information dans la mémoire partagée).

Aussi, comment dois-je identifier ce thread spécifique par la combinaison de processus ID et l'ID de thread plus tard? Comment vérifier si le fil est toujours en cours d'exécution ou non?

Id de processus et thread Id peuvent être réutilisés, je crois donc que l'ensemble de votre approche est erronée...
Vous êtes de droite. Supposons différents processus et les threads de toujours avoir des Identifiants différents pour séparer les préoccupations.

OriginalL'auteur Terry Li | 2011-12-19

  1. 4

    Si vous souhaitez stocker pid_t et pthread_t n'importe où, vous devez utiliser leurs types (c'est à dire "pid_t" et "pthread_t"). Donc, si vous voulez les stocker dans la mémoire partagée, quelque part, faire un memcpy() d'y arriver.

    Pour autant que l'identification des threads spécifiques par des combinaisons de PID et le TID, voir Nemo commentaire.

    Si vous décidez de faire l'hypothèse qu'ils existent, vous pouvez avoir votre programme regarder /proc pour trouver le pid du répertoire, et en regardant dans /proc/<pid>/task pour les threads.

    Quelles sont les types de pid_t et pthread_t?
    Ils sont opaques; vous ne devriez pas essayer d'utiliser d'une manière autre que "certaines bloquer je ne connais pas les spécificités de," depuis leur mise en œuvre pourrait changer à tout moment.
    Afin de memcpy() peut comprendre comment le nombre d'octets à copier pour moi? Alors ce que je dois faire est de réserver un bloc de mémoire qui est assez grand pour contenir tout type pthread_t? Par la manière, la vérification /proc/<pid>/tâche est la seule façon d'obtenir le statut de ce thread spécifique?
    memcpy(dest, src, sizeof(pthread_t)) devrait être en mesure de copier tout pthread_t, et de même pour pid_t. Aussi loin que l'aide du système de fichiers / proc, je ne crois que c'est le Linux façon de le faire. Je ne sais pas si il y a une autre (ou mieux) les moyens. Je vous conseille d'utiliser une structure si vous voulez togeter, Matteo Italia suggéré.
    J'aimerais réserver la même quantité de mémoire pour chaque ID de processus et thread paire. Sur le même système, serait sizeof(pthread_t) et sizeof(pid_t) nous donne toujours la même taille?

    OriginalL'auteur Dan Fego

  2. 3

    Vous pouvez utiliser pthread_join comme un brut moyen de détection de l'achèvement, mais je suis sûr que c'est pas ce que vous voulez. Au lieu de cela, vous devez gérer vous-même par la création d'un thread complet drapeau. Une belle manière de mettre ce drapeau est dans le pthread nettoyage des gestionnaires. Voir cette post

    +1 pour le lien!

    OriginalL'auteur Chris Mansley

  3. 2

    Pourquoi ne pas vous emballer dans un struct?

    typedef struct
{
    int procID;
    pthread_t threadID;

} ProcThreadID;

    sans se soucier de la spécifique de type sous-jacent de pthread_t (après tout, nous sommes dans C, donc tout ce qui est de la GOUSSE et peuvent être copiés à l'aveuglette avec memcpy).

    Vous pouvez obtenir de sa taille facilement à l'aide de la sizeof opérateur:

    size_t ptIDSize = sizeof(ProcThreadID);

    et vous pouvez le copier où vous voulez avec un simple memcpy.

    Je serialise pthread_t des données dans la mémoire partagée, donc je ne suis pas sûr de savoir comment il pourrait fonctionner pour moi.
    Depuis pthread_t est certains typedef pour un type de données C il est copyiable avec un memcpy par définition. Si c'était le C++ (où les objets peuvent avoir copie des constructeurs, de la surcharge des opérateurs d'affectation, vtable des pointeurs et d'autres choses cachées), vous devez être prudent, mais ici il n'y a pas de danger à tous.
    Je vais utiliser ce. En passant, une idée de comment je peux m'identifier à un thread spécifique par son ID et l'ID de thread et de vérifier si elle est encore en cours?

    OriginalL'auteur Matteo Italia

  4. 0

    commande pour obtenir l'id de thread s'exécute dans un processus

    $ ps -eLf | grep 14965

    UID PID PPID LWP C NLWP STIME TTY TIME CMD
    root 14965 14732 14965 0 201 15:28 pts/10 00:00:00 ./a.out
    root 14965 14732 14966 0 201 15:28 pts/10 00:00:00 ./a.out
    root 14965 14732 14967 0 201 15:28 pts/10 00:00:00 ./a.out
    root 14965 14732 14968 0 201 15:28 pts/10 00:00:00 ./a.out
    root 14965 14732 14969 0 201 15:28 pts/10 00:00:00 ./a.out
    root 14965 14732 14970 0 201 15:28 pts/10 00:00:00 ./a.out
    root 14965 14732 14971 0 201 15:28 pts/10 00:00:00 ./a.out
    root 14965 14732 14972 0 201 15:28 pts/10 00:00:00 ./a.out

    Voici la 4ème colonne (LWP) montre tous les threads en cours d'exécution dans le processus avec l'ID 14965

    OriginalL'auteur Vinayak S M