Implémentation file d'attente

Bonjour,

J'aimerais implémenter une file d'attente, des personnes X arrivent dans une file d'attente, la file est borné et les personnes X ont un temps d'attente max.

Des personnes Y traitent les demandes des personnes Y par ordre d'arrivée.

A chaque fois qu'une personne Y est libre, une personne X peut être diriger vers elle.

Il peut y avoir plus ou moins de personnes Y au fur et à mesure.

Quelle est la meilleur méthode pour implémenter cette file d'attente ?

ConcurrentQueue, BlokedQueue ?

En design pattern j'en ai trouvé 2 qui pourrait me servir : Consumer/Producer et Observable/Observer.

Merci d'avance pour vos réponses.

ta file: une ArrayBlockingQueue avec un capacité égale à ta borne de file d'attente.

Tes personnes X: des threads qui vont faire un offer(tache, timeout, timeUnit)Les personnes qui traitent les demandes: autant de thread qui feront des poll ou des take (suivant que tu veux attendre indéfiniment ou pas)

ArrayBlockingQueue : ok

Par contre pour le timeout je n'arrive pas à le faire fonctionner.

J'ai besoin de savoir à quelle moment une personne X quitte la file pour pouvoir effectuer un traitement.

Et aussi pour les personnes Y, il ne faut pas que ça soit la même personne qui traite à chaque si d'autres personnes Y sont dispo. Ils faut que ça tourne.

Ben c'est au moment où un thread prend en charge la tache qui se trouve dans la queue, donc le thread peut très bien inscrire ça dans la tâche en question.

Si c'est le timeout de mise en queue (personne qui abandonne) qui t'intéresse, tu le saura du coté de l'appelant.

Ok je vais testé et je te dis ça merci.

Mais en gros c'est coomme le design pattern consommateur / producteur non ?

PS : j'ai édit mon post au dessus

oui