Ordonnancement Thread Java

Je cherche à implémenter un ordonnanceur de thread en se basant sur l'algorithme d'ordonnancement Earliest Deadline First (EDF). Il s'agit d'un algorithme préemptif à priorité dynamique utilisé dans les systèmes temps réel. Il attribue une priorité à chaque thread en fonction de l'échéance de ce dernier. Plus l'échéance d'une tâche est proche, plus sa priorité est grande.

J'ai attribuer à chaque thread une échéance et une priorité. Chaque thread crée est enregistré dans un vecteur global.

S'il vous plait, pouvez vous m'indiquer comment implémenter l'ordonnanceur et quand est ce que je doit l'appeler, après la méthode start() ou au cours de la méthode run() ?

Merci d'avance.

La priorité d'un Thread est modifiable via la méthode setPriority.
Tu devras réviser toutes les priorités des Threads à chaque création d'un nouveau Thread et à chaque changement d'échéance d'un Thread. Ces changements se feront dans le run de l'ordonnanceur.

Bonjour, merci de m'avoir répondu.

Selon mon application la priorité d'un thread est de type double (elle est calculée en fonction de l'échéance). Alors que selon la méthode setPriority, la priorité doit être de type int !!!

C'est à toi de faire l'interfaçage entre ta donnée brut et le type borné attendu par la méthode.
La priorité d'un Thread est entre les bornes [MAX_PRIORITY;MIN_PRIORITY].

Explique comment tu obtiens ta valeur en double.

Un livre "Java tête la première" traite bien ce cas et l'explique bien.

priorité = 1/échéance

L'échéance d'un thread est calculée en fonction du temps d'arrivé au système, (CurrentTimeMillis()).

Tu peux faire une simple règle de trois.
Tu sais que la priorité calculée est un flottant entre 0 et 1.
Tu sais que la priorité d'un Thread se situe entre MIN_PRIORITY et MAX_PRIORITY.

La priorité à donnée à chaque Thread est donc :

Code:

---

1 2	int priorite = (int)( MIN_PRIORITY + (MAX_PRIORITY - MIN_PRIORITY) / echeance );

---

Là ma curiosité est piquée....
Je crois que ceci ne va pas fonctionner complétement puisque les stratégies de l'ordonnanceur sont dépendantes du système et faire joujou avec les priorités ne va pas avoir l'effet garanti attendu.
maitenant je serais curieux de savoir si un truc comme ça peut marcher et dans quelles circonstances....

edit: il y a des trucs d'échéances en java "temps réel" mais, si je me souviens bien, on ne garantit rien (sauf d'être prévenu si on n'arrive pas à son but dans le temps imparti).

essayer de faire du temps réel en java, c'est suicidaire. Rien que la présence du GC empêche de garantir les temps d'exécution ;)

Il y a toujours l'API de Java RTS de sun :
http://java.sun.com/javase/technolog...time/index.jsp

Mais bon, c'est sur que java n'est pas le langage le plus adapté pour faire du temps reel... Il ne faut pas oublier que c'est l'objectif de l'application qui devrait orienter le langage utilisé (ainsi que d'autre choses comme la portabilité, la lecture, ...) et pas le choix du langage qui introduit des contraintes.
Ceci dit, ce serait bien d'expliquer le besoin (devoir scolaire, projet perso?) pour savoir vers quoi il faut s'orienter (re-implementation d'un algo EDT, ...)

a+

Citation:

---

Envoyé par hwoarang

Il y a toujours l'API de Java RTS de sun :
http://java.sun.com/javase/technolog...time/index.jsp

---

Ce n'est qu'une partie du problème, il faut encore avoir l'OS temsp réel et le CPU temps réel :roll:

Citation:

---

Envoyé par tchize_

Ce n'est qu'une partie du problème, il faut encore avoir l'OS temsp réel et le CPU temps réel :roll:

---

Oui. Et aussi, savoir qu'est ce qu'on entend par temps reel. Je me rappelle avoir lu quelqu'un qui cherchait un programme temps reel pour faire de l'affichage de données (pour etre lu par un client) :lol: