Salut,
je souhaite faire ceci :

-Endormir un thread jusqu'à qu'au moins un événement soit généré.

-Lorsque le thread est réveillé, l'endormir pendant quelque temps pour éviter les appels trop nombreux à lock et puis traiter un événement et ainsi de suite.

-Ensuite je souhaite bloqué les autres threads le temps du traitement d'un événement et les réveillé lorsque l'événement est traité.

J'ai donc fait quelque chose comme ceci.

Code cpp : Sélectionner tout - Visualiser dans une fenêtre à part
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
#ifndef ODFAEG_ENTITY_SYSTEM_HPP
#define ODFAEG_ENTITY_SYSTEM_HPP
#include <condition_variable>
#include <mutex>
#include <thread>
#include "export.hpp"
#include <chrono>
/**
*\namespace odfaeg
* the namespace of the Opensource Development Framework Adapted for Every Games.
*/
namespace odfaeg {
/**
* \file entitySystem.h
* \class EntitiesSystem
* \brief base class of all entities systems of the odfaeg.
* \author Duroisin.L
* \version 1.0
* \date 1/02/2014
*/
class ODFAEG_CORE_API EntitySystem {
public :
    /**
    *\fn EntitySystem ()
    *\brief constructor.
    */
    EntitySystem () : needToUpdate(false) {
        running = false;
        g_notified = true;
    }
    /**
    *\fn void launch()
    *\brief launch the thread to update every entities of the entity system.
    */
    void launch () {
        running = true;
        m_thread = std::thread (&EntitySystem::run, this);
 
    }
    /**
    *\fn void update()
    *\brief function called when we need to update the entities, this function block the current thread until it's finished.
    */
    void update () {
        if (!needToUpdate) {
            g_notified = false;
            needToUpdate = true;
            g_signal.notify_one();
            std::unique_lock<std::mutex> locker (g_lock_update);
            g_signal.wait(locker, [&](){return g_notified;});
        }
    }
    /**
    *\fn void run()
    *\brief this function block this thread until we need to update the entities by calling the update function.
    * or if we want to stop the thread.
    */
    void run () {
 
        while (running) {
            std::chrono::microseconds dura(100);
            std::this_thread::sleep_for(dura);
            std::unique_lock<std::mutex> locker(g_lock_update);
            g_signal.wait(locker, [&](){return needToUpdate || !running;});
            if (needToUpdate)
                onUpdate();
            g_notified = true;
            needToUpdate = false;
            g_signal.notify_all();
        }
    }
    /**
    *\fn bool isRunning()
    *\brief tells is the thread is running.
    *\return true if the thread is running.
    */
    bool isRunning () {
        return running;
    }
    /**
    *\fn void stop()
    *\brief stop this thread.
    */
    void stop () {
        running = false;
        g_signal.notify_all();
    }
    /**
    *\fn void onUpdate()
    *\brief function to refefines to updates the entities.
    */
    virtual void onUpdate() = 0;
private :
    std::thread m_thread; /**< an internal thread which updates the entities*/
    bool running, needToUpdate, g_notified; /**< tells if the thread is running, if the entities need to be update by the thread, and, if the thread have finished to update the entities.*/
    std::condition_variable g_signal; /**<condition variable used for the primitive synchronisation of the thread.*/
    std::mutex g_lock_update; /**<mutex used in the condition variable to avoid concurrent access to a variable between different threads*/
};
}
#endif // ENTITY_SYSTEM

Cependant cela ne produit pas le comportement que je désire, je m'explique :

Les threads sont endormis avant que je fasse l'appel à g_signal.wait dans la boucle du thread, ce qui fais chuter mon FPS. :/ (Hors ça, je ne veux pas, je veux que les threads soit mis en attente après ce délai ci :

Code cpp : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
 
 std::chrono::microseconds dura(100);
 std::this_thread::sleep_for(dura);

Et j'ai un crash également avec Xlib, voici ce qu'il m'affiche ceci :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
 
[xcb] Unknow request in queue while dequeuing.
[xcb] Most likely this is a multi-thread client and XInitThreads has not been called
[xcb] Abording, sorry about that.
ODFAEG-DEMO: ../../src/xcb_io.c:179: dequeue_pending_request: Assertion '!xcb_xlib_unknown_req_in_deq' failed.
Bref, je ne sais plus trop quoi faire. :/