web-dev-qa-db-fra.com

Les threads partagent-ils des variables locales?

Je lis Operating System Concepts de Silberschatz 7th ed et indique que les threads du même processus partagent la section de code, la section de données et d'autres éléments O.S. ressources, mais ont des ensembles séparés de piles et de registres. Cependant, le problème posé sur lequel je travaille indique que les threads partagent des variables locales, mais que les variables locales ne sont pas stockées sur la pile. Par conséquent, chaque thread doit avoir sa propre copie. 

multithreadingoperating-system
8
Tony Tarng

Threads partagent généralement les éléments suivants.

  1. Segment de données (variables globales, données statiques)
  2. Espace d'adressage.
  3. Segment de code.
  4. I/O, si le fichier est ouvert, tous les threads peuvent le lire/écrire.
  5. Identifiant du processus du parent.
  6. Le tas

Mais threads conserve sa propre copie de stack, et les variables locales sont stockées sur la pile. Vous avez donc raison de dire que chaque thread devrait avoir sa propre copie des variables locales.

Peut-être que sa terminologie est mauvaise ou peut être spécifique à un ensemble de problèmes.

15
Sumeet

Les threads des systèmes d'exploitation compatibles POSIX doivent partager des variables locales (variables automatiques.a.k.). Extrait du volume XBD, Définitions de base, chapitre 3, Définitions, entrée 3.404, fil de discussion de la Ouvrir les spécifications de base du groupe, problème 7 (au moment de répondre):

Tout ce dont l’adresse peut être déterminée par un thread, y compris mais non limité aux variables statiques, le stockage obtenu via malloc (), le stockage directement adressable obtenu par des fonctions définies par l’implémentation et les variables automatiques, est accessible à tous les threads du même processus.

Le code suivant, avec la sortie 10, devrait suffire à illustrer ma revendication, si l’on suppose que les variables statiques sont effectivement partagées entre les threads:

#include <pthread.h>
#include <unistd.h>
#include <stdio.h>

static int* shared_pointer = NULL;

void* alter_thread_entry(void* arg) {
    // The following variable will be reachable,
    // while it exists, by both the main and the alter thread.
    int local_variable = 10;
    shared_pointer = &local_variable;
    sleep(2);
    return 0;
}

int main() {
    pthread_t alter_thread;
    pthread_create(&alter_thread, NULL, alter_thread_entry, NULL);
    sleep(1);
    printf("%i", *shared_pointer);
    fflush(stdout);
    pthread_join(alter_thread, NULL);
}

La pile call qui trace le contrôle de l'exécution des threads n'est pas partagée entre les threads d'un processus. Cependant, ce point dépend de la mise en œuvre, car rien n’est établi à ce sujet dans la norme susmentionnée.

1
Jonathan Ginsburg

J'ai lu qu'un processus unique peut avoir plusieurs threads. Plusieurs threads du même processus partagent des choses entre eux. Si vous voulez savoir ce qu’ils partagent et ce qu’ils ne partagent pas. Considérant que le processus comprend l'espace d'adressage, la pile, le tas, les variables globales, le code, les données, les ressources du système d'exploitation, qu'est-ce qui est partagé par les threads? J'ai des suppositions suivantes: 

Variables globales - J'ai lu la variable globale des partages de threads. Aussi, lors de la programmation en Java et C #, j'ai créé des threads pour partager la classe variables de niveau. Donc, je crois que les discussions partagent global variables (bien que je ne sois pas sûr que les concepts des langages de programmation de haut niveau soient traduits tels quels par un niveau de système d’exploitation bas faits).

Heap - Comme la variable globale est stockée dans le tas, le tas est partagé entre les threads.

Stack - Chaque thread pouvant avoir sa propre séquence/code d'exécution, il doit avoir sa propre pile sur laquelle il pourrait appuyer/décompresser son contenu de compteur de programme (quand la fonction say appelle et retourne arrive). Ainsi, les threads du même processus ne partagent pas la pile. Maintenant je suis incertain sur le partage des choses suivantes

Espace d'adressage - Vous ne savez pas exactement ce qui compte sous l'espace d'adressage. Mais j'imagine que l'espace d'adressage est généralement utilisé dans le contexte de des processus, pas des threads. Et puisque tous les threads du même processus résident dans le même espace d'adressage que le processus parent, il est dit que Blockquote les threads partagent un espace d'adressage. (Mais ensuite, ils maintiennent une pile différente Dans le même espace d'adressage?)

Ressources du système d'exploitation - Je suppose que cela peut être très spécifique à la mise en œuvre. Par exemple, le processus parent peut sélectivement donner le handle du même fichier à certains de ses fils et pas à tous. Ou je me trompe et ressources OS signifie autre chose que des fichiers?

Code - Les threads peuvent avoir un code différent, le partage de code n'est donc pas toujours le cas.

Données - Vous ne savez pas quoi prendre en compte dans les données. Mais assurez-vous que les variables globales sont partagées entre les threads. Et bien sûr que local les variables ne sont pas partagées de la même manière. Globalement, je suis considérablement confus en raison de termes vagues, super-généralisations effectuées dans le fichier Operating Livres système et détails spécifiques à la mise en œuvre fournis en ligne. J'essaie donc de trouver une réponse qui puisse me satisfaire.

Je suis donc parvenu à la conclusion que les threads conservent leur propre pile et que les variables locales sont stockées sur la pile, ce qui rend impossible le partage des variables locales dans les threads.

1
Akshay Tilekar

Je vais essayer d'expliquer avec des mots simples. Gardez trois choses à l'esprit

Empiler

Heap - variable GLOBAL

segment de code - code et certaines variables statiques

Maintenant je viendrai empiler

Chaque thread a sa propre pile et le thread libère sa pile après exécution. Et la pile est personnelle à thread, cela signifie que personne ne peut y accéder autre que son thread propriétaire.

Donc, les variables locales et dans la pile du thread principal et un autre thread auront leur propre pile, il est donc impossible que les threads puissent partager des variables locales.

J'espère que ça aide.

0
Amit Sharma

Les threads d'un processus partagent le même espace d'adressage.

Une "variable" est un concept de langage de programmation. Les variables disparaissent lorsque le code source passe par le compilateur (certaines peuvent être réduites à des symboles).

Les threads peuvent partager absolument toute la mémoire. Un thread peut accéder à n'importe quel emplacement mémoire d'un autre.

La facilité avec laquelle cela est fait dépend du langage de programmation et du support de l'éditeur de liens sous-jacent. Il existe très peu de langages de programmation qui prennent réellement en charge les threads (par exemple, Ada, appelé texte). Ada dispose de mécanismes explicites permettant aux threads de partager des données à l'aide de variables. 

Donc alors:

Je lis Operating System Concepts de Silberschatz, 7e éd, 

C'est le début de votre problème.

il dit que les threads du même processus partagent la section de code, la section de données et d'autres éléments O.S. Ressources,

Il y a tous les concepts spécifiques au système. Dans de nombreux systèmes, il n’existe pas de "section de code" ni de "section de données". Il y a simplement de la mémoire avec des attributs spécifiques (par exemple, lecture seule, lecture/écriture, lecture/exécution).

mais avoir des ensembles séparés de piles et de registres. 

Les registres sont une ressource système allouée lors de la planification du thread. Un thread n'a pas son propre ensemble de registres. Chaque thread a son propre ensemble distinct de valeurs de registre qui sont chargées lorsque le thread est actif et sauvegardées lorsqu'il devient inactif.

Les piles ne sont que des blocs de mémoire en lecture/écriture.

Cependant, le problème posé sur lequel je travaille indique que les threads partagent des variables locales, mais que les variables locales ne sont pas stockées sur la pile. Par conséquent, les threads individuels doivent avoir leurs propres copies.

Encore une fois, les threads partagent la mémoire. Ils ne partagent des variables "locales" que si le langage de programmation utilisé prend en charge un tel partage ou que ce partage se produise par "accident". 

Le mappage des variables sur l'utilisation du type d'allocation de mémoire est une fonction du compilateur. FORTRAN 66/77 et COBOL n’allouent normalement aucune variable sur la pile

0
user3344003