Mutex donnée commune MainLoop et Async socket

Je cherche une solution pour que ma boucle principale accède à une pile de messages (std::stack<Ogre::String> dernier entré premier sorti).
Les messages lus sont supprimés de la pile ( logique c'est une pile ).
J'ai un client ( boost::asio::ip::tcp ) qui récupère les messages du serveur de manière asynchrone et les ajoutes à la piles.

Je voudrais mettre cette pile de messages dans un mutex.
Je souhaite utiliser boost::mutex.

Est ce faisable même si je n'utilise pas boost::thread pour ma main loop ( boucle de rendu d'Ogre. )

Si oui comment le feriez vous, c'est la première fois que je fais joujou avec les mutex et j'ai un peu de mal à concevoir la chose pour le moment.

Voici quelques liens :
http://matthieu-brucher.developpez.c...st/thread/#LII
http://stackoverflow.com/questions/1...king-the-mutex

[EDIT]

Voici mon idée :

Headers:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
            class MessagesStack : public Ogre::Singleton<Ca::Network::Tcp::MessagesStack>
            {
                public:
                    typedef std::stack<Ogre::String> Messages ;
 
                    /** Renvoi la copie de m_Messages et efface m_Messages
                    */
                    Ca::Network::Tcp::MessagesStack::Messages GetMessages() ;
 
                    /** Ajoute en bas de la pile un nouveau message
                    */
                    void PushMessage( const Ogre::String &inMessage ) ;
 
                    MessagesStack() ;
                    ~MessagesStack() ;
 
                    static Ca::Network::Tcp::MessagesStack& getSingleton() ;
                    static Ca::Network::Tcp::MessagesStack* getSingletonPtr() ;
 
                private:
                    Ca::Network::Tcp::MessagesStack::Messages m_Messages ;
 
                    boost::recursive_mutex m_Mutex ;
            };

Sources :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
template<> Ca::Network::Tcp::MessagesStack* Ogre::Singleton<Ca::Network::Tcp::MessagesStack>::ms_Singleton = NULL ;
 
//////////////////////////////
/* MessagesStack            */
//////////////////////////////
 
Ca::Network::Tcp::MessagesStack::MessagesStack()
{}
 
Ca::Network::Tcp::MessagesStack::~MessagesStack()
{}
 
Ca::Network::Tcp::MessagesStack& Ca::Network::Tcp::MessagesStack::getSingleton()
{
    boost::recursive_mutex::scoped_lock aLock( m_Mutex ) ;
 
    M_ASSERT_NULL( ms_Singleton, "Ca::Network::Tcp::MessagesStack& Ca::Network::Tcp::MessagesStack::getSingleton()" )
    return ( *ms_Singleton ) ;
}
 
Ca::Network::Tcp::MessagesStack* Ca::Network::Tcp::MessagesStack::getSingletonPtr()
{
    boost::recursive_mutex::scoped_lock aLock( m_Mutex ) ;
 
    return ms_Singleton ;
}
 
Ca::Network::Tcp::MessagesStack::Messages GetMessages()
{
    boost::recursive_mutex::scoped_lock aLock( m_Mutex ) ;
 
    Ca::Network::Tcp::MessagesStack aMessages = m_Messages ;
 
    m_Messages = Ca::Network::Tcp::MessagesStack::Messages() ;
 
    return aMessages ;
}
 
void Ca::Network::Tcp::MessagesStack::PushMessage( const Ogre::String &inMessage )
{
    boost::recursive_mutex::scoped_lock aLock( m_Mutex ) ;
 
    m_Messages.push( inMessage )
 
}

EDIT:

Bon ça pas l'air d'être la logique. Je pense que je vais mettre m_Mutex en static et laisser les fonctions appelantes enrober l'appel d'un boost::recursive_mutex::scoped_lock aLock( m_Mutex ) ;

Dans getSingletonPtr() et getSingleton()

error: invalid use of member 'Ca::Network::Tcp::MessagesStack::m_Mutex' in static member function