bonjour ,
une question svp ,,,
on a une thread T1 qui demande l'accès a une ressources , avant la thread T2 comment garantir que la demande de T1 sera exceuté avant T2 ?
merci
Version imprimable
bonjour ,
une question svp ,,,
on a une thread T1 qui demande l'accès a une ressources , avant la thread T2 comment garantir que la demande de T1 sera exceuté avant T2 ?
merci
La meilleure stratégie est fonction du contexte de ton application.
Toutefois il existe plusieurs possibilités, parmi lesquelles :
- "brancher" T2 sur la fin de T1 - join()
- synchroniser la manipulation de la ressource, mais cela ne te garantit pas que T1 la manipulera avant T2. Pour assurer cela, tu pourrais par exemple marquer la ressource en fonction du thread qui agit dessus (cela dit, dans les cas que j'ai connus c'est loin d'être la meilleure des idées). Attention toutefois, la synchronisation peut vite générer un casse-tête en matière de performances.
- utiliser un flag te permettant d'exécuter l'accès à la ressource dans T2 (ou de démarrer T2) sous une condition particulière (que T1 l'aie modifiée par exemple). Cette condition peut aussi être liée au temps.
D'autres stratégies sont possibles, mais dans tous les cas, il faut choisir en fonction du contexte. Si tu postais des détails sur le fonctionnement attendu de l'application, ce serait probablement plus simple.
merci welcome_59,,,,voici plus de details :
il s'agit en fait d'un jeu que je suis entrain développer ( guerre des robots ) :
Une fois le moteur du jeu démarré, il consulte le répertoire contenant les descriptions des différentes armées, et par introspection, instancie les différentes armées, et place les robots au hasard sur l'arène. Chaque robot sera implanté par un processus léger séparé, dont le jeu est responsable de la gestion (en particulier, c'est au jeu de créer/démarrer/arrêter les processus légers qui exécutent le code des robots). Un contexte d'évolution est fourni par le jeu à chaque robot, à sa création (voir les interfaces qui vous sont fournies). En particulier, le contexte contient une méthode radar() qui permet au robots de consulter ses alentours. Chaque robot peut à n'importe quel moment demander au jeu d'exécuter une action (poser une bombe, se déplacer). La demande d'action est bloquante passive. Elle est prise en compte à chaque tour par le jeu, dans l'ordre où elle est arrivée. Par exemple, si un robot R1 demande une action pour le tour de jeu suivant avant un autre robot R2, alors le jeu garanti que l'action de R1 sera exécuté avant celle de R2. Un robot peut demander au jeu des informations sur le jeu, par exemple sur les autres robots de la même armée
voila :roll:
Salut,
Tu peux utiliser la classe Semaphore. D'apres la javadoc :
a+Citation:
When fairness is set true, the semaphore guarantees that threads invoking any of the acquire methods are selected to obtain permits in the order in which their invocation of those methods was processed (first-in-first-out; FIFO)
Dans ton cas, je ferai une sorte de pile des ordres.
A chaque fois, qu'un autre est lancé, tu empiles un flag (un objet, un evenement, un string, ...) qui identifie l'ordre. Ensuite, tu dépiles tes ordres dans FIFO et comme ca, tu es sur de la chronologie...
Facile à dire...pas facile à faire..
Le probleme de ce genre de systeme, c'est qu'ils sont synchronisés (au sens java du terme). Et si 2 threads sont bloqués en meme temps dans un bloc "synchronized", la machine virtuelle ne garantie pas que le premier qui attend est le premier qui passe. Ce qu'elle garantie, c'est que 2 threads n'auront pas la main en meme temps. Donc ca ne suffit pas pour ce qui est demandé...Citation:
Envoyé par alexadvance
Le meilleur moyen de garantir l'ordre des tâches, c'est de les faire exécuter par un seul thread.