Bonjour OC

dans le cadre de mon avancée sur le livre de Mr Scott Meyers, je fais actuellement un nouvel aparté sur la notion de mutex que je commence à bien assimiler.

Par curiosité , j'ai cherché à compiler et exécuter l'exemple de code à la page: 

https://en.cppreference.com/w/cpp/thread/mutex

Or en le faisant, je constate que l'on a systématiquement le résultat suivant à l'exécution :

http://bar => fake content

http://foo => fake content

J'aimerais comprendre pourquoi malgré les nombreuses exécutions que j'ai lancées de ce code, je n'ai jamais :

http://foo => fake content

http://bar => fake content

avec donc foo en premier, puisque à priori, puisque l'on est dans le cadre des threads, il n'y a pas de raison pour que ce ne soit pas foo qui s'affiche en premier. Or j'ai exécuté plusieurs fois le code et c'est toujours dans l'ordre bar, foo que ça s'affiche. 

Est-ce pareil chez vous ?

Pour rappel, voici le code issu de la page citée plus haut :

#include <iostream>
#include <map>
#include <string>
#include <chrono>
#include <thread>
#include <mutex>
 
std::map<std::string, std::string> g_pages;
std::mutex g_pages_mutex;
 
void save_page(const std::string &url)
{
    // simulate a long page fetch
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::string result = "fake content";
 
    std::lock_guard<std::mutex> guard(g_pages_mutex);
    g_pages[url] = result;
}
 
int main() 
{
    std::thread t1(save_page, "http://foo");
    std::thread t2(save_page, "http://bar");
    t1.join();
    t2.join();
 
    // safe to access g_pages without lock now, as the threads are joined
    for (const auto &pair : g_pages) {
        std::cout << pair.first << " => " << pair.second << '\n';
    }
}

Merci par avance pour votre aide

-
Edité par pseudo-simple 7 février 2019 à 11:57:04

Parce que les résultats sont stockés dans une map et que les éléments sont triés par clé.

A la limite avec un unordered_map tu as à priori ptet des chances d'avoir des résultats différents, mais sur un programme si court pas sur.

-
Edité par Maluna34 7 février 2019 à 11:56:38

void save_page(const std::string &url)
{
    // simulate a long page fetch
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::string result = "fake content";
    {  
        std::lock_guard<std::mutex> guard(g_pages_mutex);
        g_pages[url] = result;
    }
        // autre opérations éventuelles.
}

Salut,

Ou, carrément, au lieu d'utiliser une std::map, j'utiliserais tout simplement un std::vector, et, au lieu d'insérer "fake content" comme valeur, j'insèrerais carrément l'url sensément donnée...

De cette manière, tu aurais -- au moins -- une petite chance de constater l'ordre dans lequel les différents threads sont arrivés à utiliser le mutex