J'ai un projet a realiser en java pour demain ... autant dire que ca va etre
chaud.....
Un partie du probleme est le suivant
Des processus , donc des threads sont des clients et doivent passer par une
caisse quelconque.
La queueu est commune a toutes les caisses ( comme a la poste).
Si le queue est vide -> regarder si y'a de la place dans une des caisses .
Si oui y aller sinon entrer dans queue.
Si queue est pleine partir.
Si il y a de a place dans queue alors y rentrer.
Le probleme avec un solution classique est que lorsqu' un client partira de
la caisse en faisant un notify il va reveiller quelqu'un de la queue au
hasard.
Et dans ce projet c'est le premier entrer dans la queue qui doit etre le
premier a en sortir.
On peut supposer que l'ordonnanaceur de java est FIFO mais ceci n'est pas
entierement exact et rigoureux.
Voici mes deux pistes de recherche actuelle
faire un notifyall()
les client sont reveillé
il font numplacedansqueue--
si numplacedansqueue!=-1
alors il se rendort
sinon
il va a une caisse de dispo
ce qui suppose de gerer des indices de premier entré et premier sorti dans
la file etc etc etc...
ou
le client passe n'est plus un processus mais plusieurs les un a l suite des
autres:
d'abord un acheteur
puis un payeur
l'acheteur arrive aux caisse si il y a de la place
on stocke ses parametre
on le tue et
on creer un payeur avec les memes parametres
si la queue n'est pas pleine
on stocke ses parametre dans un tableau de record par ex
tableau[indiceentrée]=parametres du acheteur
indiceentree++;
indiceentre = indicentree % taille totale queue
on le tue
si la queue est pleine
j'en sais rien encore .. ;-)
lors d'un sortie de caisse
on fait un new payeur(tableau[indicesortie])
indice sortie ++;
indice sortie = indicesortie % taille totale queue
On peut remarquer pour finir que ces deux solutions sont nulles. C'est tres
moches comme programation.
Et je ne le erais qu'en dernier recours.
Le meiux serait d'endormir dans u ntableau de thread.
Puis de reveiller un seul thread et pas n'importe lequel :le premier
element du tableau.
Est possible
Il parait que non
Je pense que si
Mais a quel prix
Je n'ai jamais fait de java avant aujourd'hui il me reste donc cette
nuit.......
--------Et je ne dois pas importer autre choses que java.*-------
Donc pas de librairie magique auquel personne ne comprend rien et qui marche
apr mirracle ;-)
Si quelqqu'un a une idée ou peut me dire qi l'une de mes deux solutions est
valable et pertinehntes et pas trop moche finalement ....
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Benoît Chauvet
news.wanadoo.FR wrote:
Bonjour, Bonjour,
J'ai un projet a realiser en java pour demain ... autant dire que ca va etre chaud.....
Halala, ces étudiants qui s'y prennent toujours au dernier moment ! :D
Bon, ton problème me semble assez simple si tu le prennais par l'autre bout. Au lieu de te focaliser sur tes threads, tu devrais réfléchir à une classe file d'attente qui : - mémoriserait les thread en attente (avec leurs indices) - réveillerait le premier lorsqu'un place se libère.
Tu peux imaginer un moyen quelconque pour ce dernier point. Le plus simple si le mécanisme standard des thread ne te suffit pas est de définir une interface pour tes Threads qui te permettra de leur signaler (par la mise à jour d'un boolean, ou plus simplement l'affectation d'une caisse) qu'ils ont le droit d'avancer ou non. Ainsi, la classe centrale FileDAttente gère le placement dans les caisses, et affecte une caisse au premier thread de la file. Je pense d'ailleurs que cette gestion doit aussi être gérée par cet objet lors de l'arrivée d'un thread, même si la file est vide. Ca permet d'éviter que l'un des thread viole les contraintes définies, et ne grille tout le monde dans la file d'attente (chose très agacante, surtout en cette periode de sport d'hiver qui commence)
En résumé, tous les threads de la file sont en attente (avec un wait) et tu utilises notifyAll pour les réveiller, mais ils vérifient tous avant si une caisse leur a été affectée avant de continuer. Dans le cas contraire, ils se rendorment (et seul le premier avance, donc)
Bon courage
-- Orabîg
news.wanadoo.FR wrote:
Bonjour,
Bonjour,
J'ai un projet a realiser en java pour demain ... autant dire que ca
va etre chaud.....
Halala, ces étudiants qui s'y prennent toujours au dernier moment ! :D
Bon, ton problème me semble assez simple si tu le prennais par l'autre bout.
Au lieu de te focaliser sur tes threads, tu devrais réfléchir à une classe
file d'attente qui :
- mémoriserait les thread en attente (avec leurs indices)
- réveillerait le premier lorsqu'un place se libère.
Tu peux imaginer un moyen quelconque pour ce dernier point. Le plus simple
si le mécanisme standard des thread ne te suffit pas est de définir une
interface pour tes Threads qui te permettra de leur signaler (par la mise à
jour d'un boolean, ou plus simplement l'affectation d'une caisse) qu'ils ont
le droit d'avancer ou non.
Ainsi, la classe centrale FileDAttente gère le placement dans les caisses,
et affecte une caisse au premier thread de la file. Je pense d'ailleurs que
cette gestion doit aussi être gérée par cet objet lors de l'arrivée d'un
thread, même si la file est vide. Ca permet d'éviter que l'un des thread
viole les contraintes définies, et ne grille tout le monde dans la file
d'attente (chose très agacante, surtout en cette periode de sport d'hiver
qui commence)
En résumé, tous les threads de la file sont en attente (avec un wait) et tu
utilises notifyAll pour les réveiller, mais ils vérifient tous avant si une
caisse leur a été affectée avant de continuer. Dans le cas contraire, ils se
rendorment (et seul le premier avance, donc)
J'ai un projet a realiser en java pour demain ... autant dire que ca va etre chaud.....
Halala, ces étudiants qui s'y prennent toujours au dernier moment ! :D
Bon, ton problème me semble assez simple si tu le prennais par l'autre bout. Au lieu de te focaliser sur tes threads, tu devrais réfléchir à une classe file d'attente qui : - mémoriserait les thread en attente (avec leurs indices) - réveillerait le premier lorsqu'un place se libère.
Tu peux imaginer un moyen quelconque pour ce dernier point. Le plus simple si le mécanisme standard des thread ne te suffit pas est de définir une interface pour tes Threads qui te permettra de leur signaler (par la mise à jour d'un boolean, ou plus simplement l'affectation d'une caisse) qu'ils ont le droit d'avancer ou non. Ainsi, la classe centrale FileDAttente gère le placement dans les caisses, et affecte une caisse au premier thread de la file. Je pense d'ailleurs que cette gestion doit aussi être gérée par cet objet lors de l'arrivée d'un thread, même si la file est vide. Ca permet d'éviter que l'un des thread viole les contraintes définies, et ne grille tout le monde dans la file d'attente (chose très agacante, surtout en cette periode de sport d'hiver qui commence)
En résumé, tous les threads de la file sont en attente (avec un wait) et tu utilises notifyAll pour les réveiller, mais ils vérifient tous avant si une caisse leur a été affectée avant de continuer. Dans le cas contraire, ils se rendorment (et seul le premier avance, donc)
Bon courage
-- Orabîg
Erwan David
"Benoît Chauvet" écrivait :
news.wanadoo.FR wrote:
Bonjour, Bonjour,
J'ai un projet a realiser en java pour demain ... autant dire que ca va etre chaud.....
Halala, ces étudiants qui s'y prennent toujours au dernier moment ! :D
Bon, ton problème me semble assez simple si tu le prennais par l'autre bout. Au lieu de te focaliser sur tes threads, tu devrais réfléchir à une classe file d'attente qui : - mémoriserait les thread en attente (avec leurs indices) - réveillerait le premier lorsqu'un place se libère.
Tu peux imaginer un moyen quelconque pour ce dernier point. Le plus simple si le mécanisme standard des thread ne te suffit pas est de définir une interface pour tes Threads qui te permettra de leur signaler (par la mise à jour d'un boolean, ou plus simplement l'affectation d'une caisse) qu'ils ont le droit d'avancer ou non. Ainsi, la classe centrale FileDAttente gère le placement dans les caisses, et affecte une caisse au premier thread de la file. Je pense d'ailleurs que cette gestion doit aussi être gérée par cet objet lors de l'arrivée d'un thread, même si la file est vide. Ca permet d'éviter que l'un des thread viole les contraintes définies, et ne grille tout le monde dans la file d'attente (chose très agacante, surtout en cette periode de sport d'hiver qui commence)
En résumé, tous les threads de la file sont en attente (avec un wait) et tu utilises notifyAll pour les réveiller, mais ils vérifient tous avant si une caisse leur a été affectée avant de continuer. Dans le cas contraire, ils se rendorment (et seul le premier avance, donc)
Une autre solution est que chaque Thread attende sur un objet différent (au hasard lui même...) et que l'objet FIFO ne notifie que le thread qui doit redémarrer.
"Benoît Chauvet" <benoit@chauvet.com> écrivait :
news.wanadoo.FR wrote:
Bonjour,
Bonjour,
J'ai un projet a realiser en java pour demain ... autant dire que ca
va etre chaud.....
Halala, ces étudiants qui s'y prennent toujours au dernier moment ! :D
Bon, ton problème me semble assez simple si tu le prennais par l'autre bout.
Au lieu de te focaliser sur tes threads, tu devrais réfléchir à une classe
file d'attente qui :
- mémoriserait les thread en attente (avec leurs indices)
- réveillerait le premier lorsqu'un place se libère.
Tu peux imaginer un moyen quelconque pour ce dernier point. Le plus simple
si le mécanisme standard des thread ne te suffit pas est de définir une
interface pour tes Threads qui te permettra de leur signaler (par la mise à
jour d'un boolean, ou plus simplement l'affectation d'une caisse) qu'ils ont
le droit d'avancer ou non.
Ainsi, la classe centrale FileDAttente gère le placement dans les caisses,
et affecte une caisse au premier thread de la file. Je pense d'ailleurs que
cette gestion doit aussi être gérée par cet objet lors de l'arrivée d'un
thread, même si la file est vide. Ca permet d'éviter que l'un des thread
viole les contraintes définies, et ne grille tout le monde dans la file
d'attente (chose très agacante, surtout en cette periode de sport d'hiver
qui commence)
En résumé, tous les threads de la file sont en attente (avec un wait) et tu
utilises notifyAll pour les réveiller, mais ils vérifient tous avant si une
caisse leur a été affectée avant de continuer. Dans le cas contraire, ils se
rendorment (et seul le premier avance, donc)
Une autre solution est que chaque Thread attende sur un objet
différent (au hasard lui même...) et que l'objet FIFO ne notifie que
le thread qui doit redémarrer.
J'ai un projet a realiser en java pour demain ... autant dire que ca va etre chaud.....
Halala, ces étudiants qui s'y prennent toujours au dernier moment ! :D
Bon, ton problème me semble assez simple si tu le prennais par l'autre bout. Au lieu de te focaliser sur tes threads, tu devrais réfléchir à une classe file d'attente qui : - mémoriserait les thread en attente (avec leurs indices) - réveillerait le premier lorsqu'un place se libère.
Tu peux imaginer un moyen quelconque pour ce dernier point. Le plus simple si le mécanisme standard des thread ne te suffit pas est de définir une interface pour tes Threads qui te permettra de leur signaler (par la mise à jour d'un boolean, ou plus simplement l'affectation d'une caisse) qu'ils ont le droit d'avancer ou non. Ainsi, la classe centrale FileDAttente gère le placement dans les caisses, et affecte une caisse au premier thread de la file. Je pense d'ailleurs que cette gestion doit aussi être gérée par cet objet lors de l'arrivée d'un thread, même si la file est vide. Ca permet d'éviter que l'un des thread viole les contraintes définies, et ne grille tout le monde dans la file d'attente (chose très agacante, surtout en cette periode de sport d'hiver qui commence)
En résumé, tous les threads de la file sont en attente (avec un wait) et tu utilises notifyAll pour les réveiller, mais ils vérifient tous avant si une caisse leur a été affectée avant de continuer. Dans le cas contraire, ils se rendorment (et seul le premier avance, donc)
Une autre solution est que chaque Thread attende sur un objet différent (au hasard lui même...) et que l'objet FIFO ne notifie que le thread qui doit redémarrer.
