Thread en java

Bonjour,
j'ai un programme en java... c'est un programme qui fait diminuer un temps pour chaque processus... le temps de chaque processus est contenu dans un vecteur...

tout vas bien quand je démarre un seul.. mais quand je démarre le second... quand le second est détruit... il est toujours la... j'ai la bonne méthode vecteur.removeElementAt(int_index); mais on dirait qu'elle ne veut pas fonctionner...

pouvez vous m'aider???

voici mon code... ou à http://www.nomorepasting.com/paste.php?pasteID=35920

//package tp3;

import java.util.Vector;
import java.util.Random;

/**
* <p>Titre : </p>
*
* <p>Description : </p>
*
* <p>Copyright : Copyright (c) 2005</p>
*
* <p>Société : </p>
*
* @author non attribuable
* @version 1.0
*/
class Tourniquet
{
private Vector vecteur;
Random rd = new Random();
int int_valeur_temps_depart = 0,
int_valeur_temps_execution = 0;

int quantum, int_max_quantum ;



Tourniquet()
{
this.int_max_quantum = quantum = 0 ;


vecteur = new Vector(4);
}
Tourniquet(int int_nombre_processus, int quantum)
{

this.int_max_quantum = this.quantum = quantum ;
vecteur = new Vector(int_nombre_processus);
this.Ajouter(int_nombre_processus);
}
synchronized void Ajouter(int int_nombre_processus)
{


this.int_valeur_temps_depart = rd.nextInt(5) ;
this.int_valeur_temps_execution = rd.nextInt(19) + 1 ;
int int_nombre_element_vecteur = 1 ;
if ( int_nombre_processus > 0)
{
System.out.println("debut de la fonction ajouter");

try
{

boolean trouve = false ;


System.out.println("this.int_valeur_temps_depart = " + this.int_valeur_temps_depart);
System.out.println("this.int_valeur_temps_execution = " + this.int_valeur_temps_execution);


System.out.println("int_nombre_processus = " + int_nombre_processus);

System.out.println("avant d'entrer dans la fonction if vecteur size()");
System.out.println("vecteur size = " +vecteur.size());
if ( vecteur.size() > 2 )
{
System.out.println("avant d'entrer dans la boucle while ( int_nombre_element_vecteur < int_nombre_processus && trouve == false)");
while ( int_nombre_element_vecteur < int_nombre_processus && trouve == false)
{
System.out.println("avant de vérifier les élément");
System.out.print("Integer.parseInt( ( String )vecteur.get(int_nombre_element_vecteur) )");
System.out.println("vecteur.get(int_nombre_element_vecteur) = "+ vecteur.get(int_nombre_element_vecteur));
System.out.println(Integer.parseInt( ( String )vecteur.get(int_nombre_element_vecteur) ));
try
{

if ( Integer.parseInt( ( String )vecteur.get(int_nombre_element_vecteur) ) < int_valeur_temps_depart )
int_nombre_element_vecteur+=3;
else trouve = true ;
}
catch(Exception e)
{
System.out.println("Erreur du if pour comparer les objets." + e);
System.exit(1);
}


++int_nombre_element_vecteur;
}

}

}
catch(Exception e)
{
System.out.println("erreur dans tourniquet " + e);
System.exit(1);
}

}
try
{
Integer nombre1 = new Integer(this.int_valeur_temps_depart);
Integer nombre2 = new Integer(this.int_valeur_temps_execution);
System.out.println("nombre1 =" +nombre1);

/*for (int i = 0; i < nombre1.length; ++i)
{
nombre2[i] = nombre1[i] = 0 ;
}*/
/* for(int i = 0 ; i <nombre1.length;i++)
{
System.out.println("i="+nombre1[i]);
}*/
System.out.println("Ajouter les éléments");


System.out.println("avant d'entre dans le for");
System.out.println("int_valeur_temps_depart = " + int_valeur_temps_depart);


if ( vecteur.size() > 1 )
{
System.out.println("nombre1 = " + nombre1 + " nombre2 = " + nombre2);
vecteur.insertElementAt(nombre1, int_nombre_element_vecteur-1);
vecteur.insertElementAt(nombre2, int_nombre_element_vecteur-1);
}
else
{
System.out.println("nombre1 = " + nombre1 + " nombre2 = " + nombre2);
vecteur.insertElementAt(nombre1, 0);
vecteur.insertElementAt(nombre2, 0);
}
}
catch(Exception e)
{
System.out.println("ajouter erreur " + e );
System.exit(1);
}


this.AfficherVecteur();

}



synchronized void Retirer( int int_index)
{
try
{
System.out.println("dans retirer et élément a retirer est " + int_index);
vecteur.removeElementAt(int_index);
System.out.println("element retirer ");
AfficherVecteur();
}
catch(Exception e)
{
System.out.println("Erreur dans retirer " + e);
System.exit(1);
}
}
void Mettre_A_Jour_Donnee(int int_index)
{
try
{
vecteur.setElementAt(vecteur.elementAt(int_index), int_index);
}
catch(Exception e)
{
System.out.println("Erreur dans mettre a jour " + e);
System.exit(1);
}
}
synchronized Integer Get_Valeur(int int_index)
{

Integer Zero =new Integer(0);
try
{
System.out.println("int_index = " + int_index + " vecteur size = " + vecteur.size());
if ( int_index < vecteur.size() )
{
Integer nb ;
System.out.println("vecteur.get(int_index) " + vecteur.get(int_index));
nb = (Integer)vecteur.get(int_index);
System.out.println("nb= "+ nb);

return nb;
}
else
{
System.out.println("le numéro de la case est invalide");
System.exit(1);
}
}
catch(Exception e)
{
System.out.println("erreur get valeur " + e);
System.exit(1);
}
return Zero;


}
synchronized boolean EstVide()
{
boolean retour = true ;
try
{
if ( vecteur.size() > 0 && vecteur.isEmpty() == false )
retour = false ;
}
catch(Exception e)
{
System.out.println("Erreur dans estvide() " + e);
System.exit(1);
}

return retour ;
}
int Get_Quantum()
{
return this.quantum ;
}
synchronized void Set_Quantum(int int_quantum)
{
this.quantum = int_quantum ;
}
int Get_Max_Quantum()
{
return this.int_max_quantum ;
}
synchronized void Reduire_Quantum(int int_valeur)
{
this.quantum = this.quantum - int_valeur ;
}
synchronized void AfficherVecteur()
{
for ( int i = 0 ; i < vecteur.size();i++)
{
System.out.println("vecteur case " + i + " est " + vecteur.get(i));
}
}
int Get_size_Vecteur()
{
return vecteur.size();
}
synchronized void Reduire_Temps(int int_index)
{
Integer b ;
System.out.println("dans la fonction reduiction de temps");
b = (Integer)vecteur.get(int_index);
int int_valeur = 0 ;

int_valeur = b.intValue();
System.out.println("int_valeur = " + int_valeur);
if ( int_valeur > 0 )
{
int_valeur-- ;
System.out.println("int_valeur = " + int_valeur);
vecteur.setElementAt(new Integer(int_valeur), int_index);

System.out.println("valeur à la case " + int_index + vecteur.elementAt(int_index));
}
}
}


//package tp3;
//import tp3.*;
import java.lang.Exception;
import java.io.BufferedReader;
import java.util.Vector;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.File;
import java.io.*;
import java.lang.*;


/**
* <p>Titre : </p>
*
* <p>Description : </p>
*
* <p>Copyright : Copyright (c) 2005</p>
*
* <p>Société : </p>
*
* @author non attribuable
* @version 1.0
*/
public class ProgrammePrincipal {
final static String ENTETE_PAGE_0 = "_________________________________";
final static String ENTETE_PAGE_1 = "Instant t | UC | filepret(t,q) ";
final static String ENTETE_PAGE_2 = "__________|______|_______________";
final static String PIED_PAGE_0 = "__________|______|_______________";
final static String SAUT_LIGNE = "\n";
final static String ESPACE = " ";
final static String BARRE_VERTICAL = "|";
public ProgrammePrincipal() {
}
private void EcrireFichier(String string_chaine, int int_numero_processus_action,
Vector vecteur,String string_numero_ligne,
FileWriter out, int int_numero_thread_actif)
{
//ouvrir le fichier avec microsoft word

String ligne ;
boolean ATTEINT_FIN = false;
ligne = string_numero_ligne ;

for ( int i = 0 ; i < ( 11 - string_numero_ligne.length() ) ; i++)
ligne = ligne + ESPACE;
ligne = ligne + BARRE_VERTICAL ;
ligne = ligne + ESPACE ;

ligne = ligne + vecteur.get(int_numero_thread_actif) ;
ligne = ligne + ESPACE + ESPACE ;
ligne = ligne + BARRE_VERTICAL ;


for (int i = int_numero_thread_actif + 1 ;
i < int_numero_thread_actif ||
ATTEINT_FIN == true ;
i++ )
{
if ( int_numero_thread_actif == vecteur.size() )
{
int_numero_thread_actif = 0 ;
continue ;
}
ligne = ligne + "p-" + Integer.parseInt( ( String )vecteur.get(i) );
}
try
{
out.write(ligne + "\n" );
}
catch(Exception e)
{
System.out.println(e);
System.exit(1);
}
}

public void LireFichier()
{


try
{
BufferedReader in = new BufferedReader(new FileReader("farrago.txt"));
String d;

while ( ( d = in.readLine() ) != null )
{
System.out.println(d);
}
}
catch(Exception e)
{
System.out.println("Erreur lors de la lecture");
}
}

public static void main(String args[])
{
try
{


Tourniquet tourniquet = new Tourniquet(1,50);
Horloge horloge = new Horloge(1000);
Processus zero = new Processus(horloge,tourniquet,"p-0" );
Processus premier = new Processus(horloge,tourniquet,"p-1");
//Processus second = new Processus(horloge,tourniquet,"p-2");
// Processus troisieme = new Processus(horloge,tourniquet,"p-3");

/* File outputFile = new File("farrago.txt");
FileWriter out = new FileWriter(outputFile);
System.out.println(ENTETE_PAGE_0 + SAUT_LIGNE);
out.write(ENTETE_PAGE_0 + SAUT_LIGNE);
System.out.println(ENTETE_PAGE_1 + SAUT_LIGNE);
out.write(ENTETE_PAGE_1 + SAUT_LIGNE);
System.out.println(ENTETE_PAGE_2 + SAUT_LIGNE);
out.write(ENTETE_PAGE_2 + SAUT_LIGNE);

out.write(PIED_PAGE_0 + SAUT_LIGNE);
out.close();*/

zero.start();
premier.start();
/*second.start();
troisieme.start();*/
}
catch(Exception e)
{
System.out.println("erreur dans le main " + e);
System.exit(1);
}
}
}


//package tp3;

/**
* <p>Titre : </p>
*
* <p>Description : </p>
*
* <p>Copyright : Copyright (c) 2005</p>
*
* <p>Société : </p>
*
* @author non attribuable
* @version 1.0
*/
import java.util.Random;

//import tp3.Horloge;
//import tp3.Processus;
//import tp3.Scheduler;
//import tp3.Tourniquet;
import java.util.Vector;
import java.io.FileWriter;
import java.io.File;
import java.io.BufferedReader;
import java.io.FileReader;

class Processus extends Thread
{
private int timeSlice;
private static final int DEFAULT_TIME_SLICE = 1000; // 1 second
private Horloge horloge;
Tourniquet tourniquet = new Tourniquet() ;
final static int ZERO = 48 ;
Processus()
{
}
Processus(Horloge horloge, Tourniquet tourniquet, String string_name)
{
this.setName(string_name);
this.horloge = horloge ;
this.tourniquet = tourniquet ;

}



synchronized public void run()
{
try
{
int int_index = 0;
int int_max_index = 4 ;
Integer b ;
boolean boolean_fin_traitement = false ;


int int_temps = 0 ;

int nombre[] = new int[10] ;
String string_nom_processus = this.getName();
int int_numero_processus = 0 ;
nombre[0] = 0 ;
int_numero_processus = string_nom_processus.charAt(2) - ZERO ;
Integer temps;
int valeur ;
while ( tourniquet.EstVide() == false )
{
try
{
System.out.println("quantum = " + tourniquet.Get_Quantum());



for(double i = 0 ; i < 100000000 ; i++);

while ( tourniquet.Get_Quantum() > 0 )
{
System.out.println("affichage des éléments du vecteur");
tourniquet.AfficherVecteur();
System.out.println("dans while ( tourniquet.Get_Quantum() > 0 ) ");
System.out.println("quantum = " + tourniquet.Get_Quantum());
System.out.println(this.getName() + " en exécution");
b = tourniquet.Get_Valeur(int_numero_processus);
valeur = b.intValue();
temps = new Integer(valeur);
for(double i = 0 ; i < 100000000 ; i++);
Integer integer_ZERO = new Integer(0);


string_nom_processus = this.getName() ;
System.out.println(this.getName());


try
{
System.out.println("valeur de temps : " + valeur);
if (temps.compareTo(integer_ZERO) > 0)
{
horloge.Iteration();
tourniquet.Mettre_A_Jour_Donnee(int_numero_processus );
this.sleep(timeSlice);
tourniquet.Reduire_Quantum(1);
tourniquet.Reduire_Temps(int_numero_processus);
}
}
catch(Exception e)
{
System.out.println("erreur trouver bonne place..." + e);
System.exit(1);
}

System.out.println("les if conclu");
System.out.println("premier " + this.getName());
System.out.println("valeur du temps restant du processus " + this.getName()
+ " " +tourniquet.Get_Valeur(int_numero_processus));
System.out.println("la valeur de integer_Zero est : " + integer_ZERO.intValue());
System.out.println("integer_ZERO.compareTo(tourniquet.Get_Valeur(int_numero_processus))"
+integer_ZERO.compareTo(tourniquet.Get_Valeur(int_numero_processus)) );
if (integer_ZERO.compareTo(tourniquet.Get_Valeur(int_numero_processus)) == 0)
{
System.out.println("prochaine action retirer");
tourniquet.Retirer(int_numero_processus );

break;
}
System.out.println("second " + this.getName());
if ( integer_ZERO.compareTo(tourniquet.Get_Valeur(int_numero_processus )) != 0)
int_index += 2;
else int_index = 0;
/*System.out.println("troisieme");
if ((boolean_fin_traitement == true) &&
(tourniquet.Get_Quantum() != tourniquet.Get_Max_Quantum()))
tourniquet.Set_Quantum(tourniquet.Get_Max_Quantum());
else */
this.sleep(DEFAULT_TIME_SLICE);
++int_temps;
}


}
catch(Exception e)
{
System.out.println("Erreur dans bouble tant pas vide " +e);
System.exit(1);
}
}


}
catch(Exception e)
{
System.out.println("Erreur dans start " + e);
System.exit(1);
}
}
}//package tp3;

/**
* <p>Titre : </p>
*
* <p>Description : </p>
*
* <p>Copyright : Copyright (c) 2005</p>
*
* <p>Société : </p>
*
* @author non attribuable
* @version 1.0
*/
class Horloge
{
private int int_unite_temps ;

Horloge()
{
this.int_unite_temps = 0 ;
}
Horloge(int int_unite_temps)
{
this.int_unite_temps = int_unite_temps ;
}
void Iteration()
{
for ( int i = 0 ; i < int_unite_temps ; ++i) ;
}
int Valeur_Uniter_Temps()
{
return this.int_unite_temps;
}
void Dormir(int int_temps)
{
for ( int i = 0 ; i < int_temps ; ++i) ;
}
}
merci
mousekey