bonsoir, je veux utiliser l'horloge pour delacher et ordonnancer les taches d'un processus.
j'ai assigné un temps random pour le temps d'exécution de chaque taches.mais j'ai pas trouvé comment faire attendre l'horloge pour qu'elle déclanche une tache2 après la fin de l'exécution de la tache1,càd l'horloge dois attendre la fin de tache1 pourr déclancher la tache2.
merci.  

tache1; Thread.sleep(1000); tache2

oui j'ai deja fais mais sa donne pas les résultats exéctes  
ce que j'ai fais j'ai recupéré l'hologe (heur,minutes,seconde) ensuite je assigné un temps d'exécution pour chaque taches qui égale à une valeur entiere random,le temps de fin d'une tache est calculé par temps1=(temps de l'hologe+temps d'exécution) alors pour déclacher une tache2 je dois attendre que l'horloge ==temps1 calculé avant.

du code ?

int h=calend.get(GregorianCalendar.HOUR_OF_DAY);
int min=calend.get(GregorianCalendar.MINUTE);
int sec=calend.get(GregorianCalendar.SECOND);
Vector temps=new Vector();
v.add(nom_taches);
v.add(h,min,sec)// temps de début d'une tache
temps_execution=(int)(Math.random()*30+1)
// temps d'exécution  entre 1 et 30 seconde.  
exécuter(nom_tache)// exécuter tache1
sleep(temps_execution)
// normalement je dois attendre au minimum un temps==temps  
//d'exécution de la tache1 après j'exécute la tache2
executer(tache2).  
 

 
Dis moi si j'ai bien compris ton besoin :
 - tu as 2 traitements s'exécutant dans des Thread
 - l'ordonnanceur doit lancer les 2 traitement de façon séquentielle (le traitement 2 ne se lance que quand le traitement 1 est fini)
 
=> utilise Thread.join()
 
Le code donnera un truc comme ça
 

pouvez vous me donner un exemple de code.
merci

ce que je veux fair c'est je dois bloqué l'exécution de la tache2 jusqu'à ce que le temps d'exécution de la tache1 est fini(ce temps est donné aléatoirement),j'arrive pas à avoir la valeur de ce temps exactement avec sleep(temps). parsque dans sleep(int) le temps d'attendte est considéré en milisecont mais mon temps d'exécution est généré en seconde. j'ai fais sleep(temps*1000000) pour avoir le temps en seconde mais toujours je le reçois beaucoup plus petit.

!!! 1 seconde = 1000 millisecondes !!!

oui m'ai j'ai pas toujours le résultat que je veux.

On ne comprend pas ce que tu veux ...
 
Si tu veux que la tache 2 attende que la tache 1 soit finie, il faut utiliser join et pas sleep
 
Si tu veux utiliser l'horloge (donc sleep) pour retarder la tache 2, tu n'a aucun moyen de savoir à l'avance combien de temps va mettre la tache 1 pour s'executer !
 
Montre nous ton code.

c'est juste un exemple:  
Vector temps_exe_tache=new Vector();
String[] tache;// on supose que tache est remplit
for(int i=0;i<tache.length;i++){
            temp=(int)(Math.random()*10+1);// entre 1 et 10.  
          //on asigne aux taches un temps d'exécution  
             temps_exe_tache.add(temp);
}
// je dois executer maintement les taches  
 
for(i=0;i<tache.length;i++){
  executer(tache[i]);
 //pour attendre la fin da tache(i)  j'ai fais ce code mais je recoie tjrs
 // un temps très petit  
Thread.sleep(temps_exe_tache(i));
 
}
le probleme avec join,j'ai pas le moyen de contôler le temps d'exécution de la tache1 pour bloké les autre taches.  
est ce que je peux faire une sorte de boucle qui tourne dans le vide en comptant le de 0 à temps d'exécution de tache1 pour donne la main à la tache2 de s'exécuter Càd sans passer par les threads.
merci encore

 
Justement, le principe de join c'est que tu n'as plus besoin de calculer le temps d'execution de tache 1.
 
En gros ca va te faire :
 
tache 1 s'execute autant de temps qu'elle veut,
puis une fois qu'elle se termine elle redonne la main a ton prog qui peut tranquilement lancer tache2 en etant sûr que tache 1 est finie et ainsi de suite pour la tache suivante
 
Donc tu laisses tomber sleep, et tu utilises join comme expliqué plus haut.

SVP est ce que tu peux me donner un exemple du code,j'ai dejà utilisé join mais sa n'a pas marché.

En fait là, ça dépend de ce que fait ta méthode executer et de comment elle le fait.
 
Est ce que ça lance un thread ?
Si oui, il faut que la méthode fasse un return du Thread créé.
 
Là encore, ça serait bien que tu nous montres le code de la méthode executer.
Et le vrai code, pas un truc d'exemple...

enfait la methode executer c'est une class thread qui implémente Runnable.et qui génére un temps avec la methode random.(le principe c'est sa).
 
public class execution extends Thread implement runnable{
/*
public static String tache;
public static int attendre;//le temps que la tache2 dois attendre
 
*/  
execition(String t){
this.tache=t;
attendre=execution(tache);
//normalement ici la tache2 va attendre un temps==attendre
}
// la methode qui genere un temps d'exécution pour une tache
public static int execution(String t){
int temps=(int)(Math.random()*10+1);
return temps;
}
}

SVP quelqu'un peux me donner un exemple concret du code pour la methode join.et coment je peux controler l'exécution d'un ensemble de taches sur l'axe du temps.