C++, comment partager des données entre threads ou processus

J'ai un programme qui s'exécute en deux opérations différentes et j'aimerais partager des variables entre elles.

En ce moment, je suis à l'aide de threads au lieu de fourche processus, mais je vais avoir des problèmes dans le partage de variables, même si j'ai déclaré comme volatile.

J'ai essayé avec boost:

boost::thread collisions_thread2(boost::bind(function_thread2);

en déclarant les variables partagées comme volatile, mais il semble que function_thread2() la fonction n'est pas en mesure de voir les modifications sur les variables partagées.

Ce que j'aime faire, c'est quelque chose comme:

thread1:

while(true){
//..do somet stuff
check variable1
}

thread2:

while(true){
do some other stuff
check and write on variable1
}

Pouvez-vous me suggérer un tutoriel ou une méthode de facilement partager des variables entre les threads?
Peut-être stimuler la bibliothèque peut être utile dans ce cas?
Pensez-vous qu'il est préférable d'utiliser fork()?

Je sais que je dois utiliser un mutex, afin d'éviter des situations critiques, mais je n'ai jamais utilisé.

Vérifiez si le question aide. Et, finalement, Stimuler la Synchronisation de Thread
volatile n'a rien à voir avec les threads
Vous n'avez même pas besoin volatile de partager des variables. Les variables globales sont partagés par défaut. Mais c'est une mauvaise chose car il permet de créer les données de courses facile. Lorsque vous avez des données des courses, vous ne pouvez pas attendre de votre programme à se comporter de manière raisonnable, de sorte que vous êtes probablement en cours d'exécution dans certaines variétés de cette. Vous aurez besoin de publier plus de votre code réel pour obtenir de l'aide pour le diagnostic des données courses.
Oui, vous n'avez pas besoin volatils, mais c'est une bonne pratique à utiliser dans les programmes Multithread pour éviter des bugs dus à des optimisations du compilateur.
Je ne suis pas trop familier avec cela, mais je pense que tant que vous évitez de données des courses, vous obtenez séquentielle cohérence sans l'aide de volatile. Peut-être volatile est encore nécessaire pour garantir qu'un thread fait des progrès.

OriginalL'auteur Marcus Barnet | 2012-02-29

  1. 2

    Si vous pouvez utiliser boost, vous pouvez utiliser boost::mutex.

    //mtx should be shared for all of threads.
boost::mutex mtx;

//code below for each thread
{
  boost::mutex::scoped_lock lk(mtx);
  //do something
}

    OriginalL'auteur kamae

  2. 2

    Si en utilisant les threads posix libs (que je recommande) puis utiliser pthread_mutex_t.

    pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

    Puis, dans chaque thread lorsque vous souhaitez synchroniser l'accès aux données:

    pthread_mutex_lock(&lock);
//access the data
pthread_mutex_unlock(&lock);

    OriginalL'auteur Jonathan Henson

  3. 1

    tout type de mutex verrouiller ou déverrouiller serait de travailler. En ce qui concerne votre question sur la volatilité va, ce mot-clé est une bonne pratique, en particulier dans les programmes multi-thread comme la vôtre. Mais il n'affecte pas la façon dont vous pouvez verrouiller et déverrouiller.
    volatile simplement dit au compilateur de ne pas optimiser une variable, par exemple en le mettant dans un registre. Voici une très bonne explication:

    http://drdobbs.com/cpp/184403766

    OriginalL'auteur Sid