Vous ne pouvez pas pthreads accéder aux variables de la fonction main()?

Question

int main() 
{ 
    int i; 
    pthread_t t; 
} 

peut pas voir non? t est créé à l'intérieur principal, non? Cela signifie qu'il doit utiliser la même mémoire partagée main() utilise? Comment est-ce que je le fais voir sans faire de i une variable globale?

Answer 1

Quoi? t est un fil, il ne "voit" vraiment rien. Strictement, il est une variable qui représente un fil - vous avez pas réellement créé un fil - mais en supposant que vous en créer un, il exécute dans le même processus que main(), il partage l'espace mémoire en ce sens, mais il n » t partager la portée de main. Les fonctions qui s'exécutent dans ce thread peuvent voir toutes les variables dans la portée de ces fonctions. Vous pouvez passer un pointeur sur i comme pointeur de données utilisateur sur pthread_create. Ou si vous avez besoin d'accéder à plus que i, vous pouvez passer un pointeur vers une structure qui contient (entre autres) un pointeur vers i, et ainsi de suite.

code Exemple:

#include <pthread.h> 
#include <iostream> 
#include <cstring> 

void *thread_entry_point(void *data) { 
    int *idata = static_cast<int*>(data); 
    std::cout << "thread: i = " << *idata << "\n"; 
    *idata = 23; 
    return const_cast<char*>("might as well return something"); 
} 

int main() { 
    int i = 12; 
    pthread_t thr; 

    int err = pthread_create(&thr, 0, thread_entry_point, &i); 
    if (err == 0) { 
     void *result; 
     pthread_join(thr, &result); 

     std::cout << "main: result = " << static_cast<const char*>(result) << "\n"; 
     std::cout << "main: i = " << i << "\n"; 
    } else { 
     std::cout << "error creating thread: " << err << " " << std::strerror(err) << "\n"; 
    } 
} 

Answer 2

pthreads ne sont pas particuliers. Par exemple, le code suivant a le même « problème »:

void foo() 
{ 
    i = 5; 
} 
int main() 
{ 
    int i; 
    foo(); 
} 

Sûrement foo est appelé par main, donc ils sont même sur le même fil. Pourtant, foo ne voit pas le int dans main. La solution est simple: si foo a besoin d'un int, main passerais que:

void foo(int& i) 
{ 
    i = 5; 
} 
int main() 
{ 
    int i; 
    foo(i); 
} 

avec des fils, la situation est la même: passer ce que vous avez besoin de partager.