Exemple Mutex / tutoriel?

bien qu'un mutex puisse être utilisé pour résoudre d'autres problèmes, la raison première de leur existence est d'offrir l'exclusion mutuelle et donc de résoudre ce qui est connu comme une condition de race. Lorsque deux (ou plus) threads ou processus tentent d'accéder à la même variable simultanément, nous avons un potentiel pour une condition de course. Considérons le code suivant

//somewhere long ago, we have i declared as int
void my_concurrently_called_function()
{
  i++;
}

les internes de cette fonction semblent si simples. C'est une seule instruction. Cependant, un pseudo-ensemble typique l'équivalent linguistique pourrait être:

load i from memory into a register
add 1 to i
store i back into memory

parce que les instructions équivalentes en langage d'assemblage sont toutes nécessaires pour effectuer l'opération d'incrément sur i, nous disons que l'incrément i est une opération non-atmoïque. Une opération atomique est celui qui peut être effectuée sur le matériel avec une garantie de ne pas être interrompu une fois l'instruction, l'exécution a commencé. Incrementing I se compose d'une chaîne de 3 instructions atomiques. Dans un système concurrent où plusieurs threads sont en appelant la fonction, des problèmes surgissent quand un thread lit ou écrit au mauvais moment. Imaginez que nous ayons deux threads fonctionnant simultanément et que l'un appelle la fonction immédiatement après l'autre. Disons aussi que nous avons initialisé à 0. Supposons aussi que nous avons beaucoup de registres et que les deux threads utilisent des registres complètement différents, donc il n'y aura pas de collisions. Le calendrier de ces événements peuvent être:

thread 1 load 0 into register from memory corresponding to i //register is currently 0
thread 1 add 1 to a register //register is now 1, but not memory is 0
thread 2 load 0 into register from memory corresponding to i
thread 2 add 1 to a register //register is now 1, but not memory is 0
thread 1 write register to memory //memory is now 1
thread 2 write register to memory //memory is now 1

Ce qui s'est passé, c'est que nous ont deux fils incrémentant Je concurremment, notre fonction est appelée deux fois, mais le résultat est incompatible avec ce fait. On dirait que la fonction n'a été appelée qu'une fois. Cela est dû au fait que l'atomicité est "cassée" au niveau de la machine, ce qui signifie que les fils peuvent s'interrompre ou travailler ensemble au mauvais moment.

Nous avons besoin d'un mécanisme pour résoudre ce problème. Nous devons imposer un certain ordre aux instructions ci-dessus. Un mécanisme commun est de bloquer tous les fils sauf un. Pthread mutex utilise ce mécanisme.

tout thread qui doit exécuter certaines lignes de code qui peuvent modifier les valeurs partagées par d'autres threads en même temps (en utilisant le téléphone pour parler à sa femme), doit d'abord être fait acquérir une serrure sur un mutex. De cette façon, tout thread qui nécessite l'accès aux données partagées doit passer par la serrure mutex. Ce n'est qu'alors qu'un thread pourra exécuter le code. Cette section de code est appelée une section critique.

une fois que le thread a exécuté la section critique, il doit libérer la serrure sur le mutex afin qu'un autre thread puisse acquérir une serrure sur le mutex.

le concept d'avoir un mutex semble un peu étrange lorsque l'on considère les humains qui cherchent un accès exclusif à des objets physiques réels, mais lors de la programmation, nous devons être intentionnels. Les fils et les processus concurrents n'ont pas l'éducation sociale et culturelle que nous faisons, donc nous devons les forcer à partager les données gentiment.

donc techniquement parlant, comment fonctionne un mutex? Ne souffre-t-il pas des mêmes conditions de course que celles que nous avons mentionnées plus tôt? Pthread_mutex_lock() n'est-il pas un peu plus complexe qu'un simple incrément d'une variable?

techniquement parlant, nous avons besoin d'un support matériel pour nous aider. Les concepteurs du matériel nous donnent des instructions machine qui font plus d'une chose, mais qui sont garanties d'être atomiques. Un exemple classique d'une telle instruction est l' test-and-set (TAS). En essayant d'acquérir un verrou sur une ressource, nous pourrions utiliser le TAS pourrait vérifier pour voir si une valeur en mémoire est 0. Si c'est le cas, ce serait notre signal que la ressource est utilisée et que nous ne faisons rien (ou, plus précisément, que nous attendons selon un mécanisme quelconque). Un mutex pthreads nous mettra dans une file d'attente spéciale dans le système d'exploitation et nous avertira lorsque la ressource sera disponible. Dumber systems peut nous demander de faire une boucle de spin serrée, tester la condition encore et encore). Si la valeur en mémoire N'est pas 0, le TAS fixe l'emplacement à quelque chose d'autre que 0 sans utiliser d'autres instructions. C'est comme combiner deux instructions d'assemblage en 1 pour nous donner de l'atomicité. Ainsi, tester et changer la valeur (si Changer est approprié) ne peut pas être interrompu une fois qu'il a commencé. Nous pouvons construire des Mutex en plus d'une telle instruction.

Note: certaines sections peuvent ressembler à une réponse antérieure. J'ai accepté son invitation à éditer, il a préféré la façon originale était, donc je garde ce que j'ai eu qui est infusé avec un peu de son verbiage.

le meilleur tutoriel de threads que je connaisse est ici:

https://computing.llnl.gov/tutorials/pthreads /

j'aime qu'il soit écrit sur L'API, plutôt que sur une implémentation particulière, et il donne quelques exemples simples pour vous aider à comprendre la synchronisation.

je suis tombé sur ce post récemment et pense qu'il a besoin d'une solution mise à jour pour le mutex c++11 de la bibliothèque standard (à savoir std::mutex).

j'ai collé du code ci - dessous (mes premiers pas avec un mutex-j'ai appris la concurrence sur win32 avec HANDLE, SetEvent, WaitForMultipleObjects etc).

puisque c'est ma première tentative avec std::mutex et amis, j'aimerais voir des commentaires, des suggestions et des améliorations!

#include <condition_variable>
#include <mutex>
#include <algorithm>
#include <thread>
#include <queue>
#include <chrono>
#include <iostream>


int _tmain(int argc, _TCHAR* argv[])
{   
    // these vars are shared among the following threads
    std::queue<unsigned int>    nNumbers;

    std::mutex                  mtxQueue;
    std::condition_variable     cvQueue;
    bool                        m_bQueueLocked = false;

    std::mutex                  mtxQuit;
    std::condition_variable     cvQuit;
    bool                        m_bQuit = false;


    std::thread thrQuit(
        [&]()
        {
            using namespace std;            

            this_thread::sleep_for(chrono::seconds(5));

            // set event by setting the bool variable to true
            // then notifying via the condition variable
            m_bQuit = true;
            cvQuit.notify_all();
        }
    );


    std::thread thrProducer(
        [&]()
        {
            using namespace std;

            int nNum = 13;
            unique_lock<mutex> lock( mtxQuit );

            while ( ! m_bQuit )
            {
                while( cvQuit.wait_for( lock, chrono::milliseconds(75) ) == cv_status::timeout )
                {
                    nNum = nNum + 13 / 2;

                    unique_lock<mutex> qLock(mtxQueue);
                    cout << "Produced: " << nNum << "\n";
                    nNumbers.push( nNum );
                }
            }
        }   
    );

    std::thread thrConsumer(
        [&]()
        {
            using namespace std;
            unique_lock<mutex> lock(mtxQuit);

            while( cvQuit.wait_for(lock, chrono::milliseconds(150)) == cv_status::timeout )
            {
                unique_lock<mutex> qLock(mtxQueue);
                if( nNumbers.size() > 0 )
                {
                    cout << "Consumed: " << nNumbers.front() << "\n";
                    nNumbers.pop();
                }               
            }
        }
    );

    thrQuit.join();
    thrProducer.join();
    thrConsumer.join();

    return 0;
}

la fonction pthread_mutex_lock() soit acquiert le mutex pour le fil appelant ou bloque le fil jusqu'à ce que le mutex puisse être acquis. Le pthread_mutex_unlock() produit le mutex.

Penser le mutex comme une file d'attente; chaque thread qui tente d'acquérir le mutex sera placé sur la fin de la file d'attente. Quand un thread libère le mutex, le thread suivant dans la file d'attente s'éteint et est maintenant en cours d'exécution.

Un la section critique fait référence à une région de code où le non-déterminisme est possible. Souvent, cela parce que plusieurs threads tentent d'accéder à une variable partagée. La section critique n'est pas sûre tant qu'une sorte de synchronisation n'est pas en place. Une serrure mutex est une forme de synchronisation.

vous êtes censé vérifier la variable mutex avant d'utiliser la zone protégée par le mutex. Ainsi, votre pthread_mutex_lock () pourrait (selon l'implémentation) attendre que mutex1 soit libéré ou retourner une valeur indiquant que la serrure ne pourrait pas être obtenue si quelqu'un d'autre l'a déjà verrouillée.

Mutex est vraiment juste un sémaphore simplifié. Si vous lisez sur eux et les comprenez, vous comprenez les Mutex. Il y a plusieurs questions concernant les mutex et les sémaphores dans la. différence entre le sémaphore binaire et le mutex , quand devrions-nous utiliser mutex et quand devrions-nous utiliser semaphore et ainsi de suite. Les toilettes exemple dans le premier lien est sur un exemple que l'on peut penser. Tous les code n'est de vérifier si la clé n'est disponible et si elle l'est, la réserve. Remarquez que vous ne réservez pas vraiment la toilette elle-même, mais la clé.

EXEMPLE DE SÉMAPHORE::

sem_t m;
sem_init(&m, 0, 0); // initialize semaphore to 0

sem_wait(&m);
// critical section here
sem_post(&m);

référence: http://pages.cs.wisc.edu/~remzi/Classes/537/Fall2008/Notes/threads-semaphores.txt

pour ceux qui cherchent l'exemple du vortex mutex:

#include <mutex>
using namespace std;

int main() {
    mutex m;

    m.lock();
    // do thread-safe stuff
    m.unlock();

    return 0;
}