Salut ,
 
 Je cree une aplication en mode fenetré avec SDL sous windows XP avec VC++.  
j'initialise ma sdl, je lance le rendu, ca m'affiche ce que je veux pendant 10 secondes environ apres pouf! ca deviens tout blanc avec dans la barre de titre de la fenetre monapi(ne repond pas)  
 
de plus il m'est impossible de bouger la fenetre rien (avant que ca reponde plus) ...  
 
je sais plus quoi faire

prendre un bescherelle... ça réduira une partie des pbs mais c'est pas très gentil comme réponse !
ça sent bien la boucle infini comme bug ça...

la raison viens du fait que j'utilise un thread pour le rendu, et un thread pour les evenements
quand je regroupe ces 2 threads en 1 la ca marche nikel
 
j'ai voulue faire un truc du style pour garder mes 2 threads
 
 
du cote du thread gfx
 
while(!_quit)
{
  SDL_MutexP(_mutex_gfx);
  ....
  SDL_MutexV(_mutex_event);
}
 
 
et du cote du thread events
 
while(!_quit)
{
  SDL_MutexP(_mutex_event);
  ....
  SDL_MutexV(_mutex_gfx);
}
 
 
en fesant bien attention a avoir un decalage de temp au debut affin de bien initialiser  
mais rien a faire c'est comme si chacun avais rien a battre du mutex
 
mutex gfx           mutex event
 
lock de gfx            
tratements gfx
unlock event            lock de event
lock de gfx bloquant    traitements event
lock de gfx bloquant    on unlock gfx
 
lock de gfx             lock de event bloquant
tratements gfx          lock de event bloquant
unlock event            lock de event
lock de gfx bloquant    traitements event
lock de gfx bloquant    on unlock gfx
 
   
 
sauf que dans la pratique, ils me renvoillent toujours 0 comme quoi ils arrivent a locker le thread alors qu'il est deja locke !!!  
le unlock se passe bien lui  
 

 
Quand tu utilises un mutex, il faut le verrouiller avant le traitement puis le déverrouiller à la fin du traitement. Ici, à la fin de ton bloc d'instructions, tu unlock un mutex qui n'a pas été préalablement locké. Utilises un code de ce style dans chaque thread :  
 

Un truc qui marche est de créer une classe Mutex stack-based.
Ainsi, là où l'on veut verrouiller, on n'a qu'a déclarer le mutex qui verrouille dans le constructeur, et déverrouille dans le destructeur.
Ce qui permet de faire à l'utilisation :

Au passage, ce pattern bien connu est recommandé pour toutes les acquisitions de ressources partageables, par exemple l'ouverture d'un fichier (faire une classe fichier est d'ailleurs tjrs une bonne idée), d'un port, etc.

je reveisn sur cette histoire (au final j'ai degagé le threading de mon programe)
 
mais je comprend toujours pas pkoi ca fonctionnais pas mon systeme  
 
la fonction SDL_MutexP() en sdl est bien sencée locker un mutex.  
Et etre bloquant tant que celui ci est locké ???
 
et un mutex ettant visible a partir de tout les thread ....  
 
il est possible pour  
le thread A de bloquer le mutex 1  (dans le Thread B on attend le delock du mutex1 pour reprendre l'execution)
le thread A fais son traitement   (dans le Thread B on attend toujours le delock pour reprendre l'execution)
Le thread A finis son traitemnt, delocke le mutex 1 ce qui entraine la reprise de l'execution du Thread B
 
non ?