Bonjour à tous!
 
J'ai fait un prog Java et moindrement que je lance une interface, l'utilisation de l'UC passe directement à 100% même avec un Bi-processeur!
 
Pouvez-vous me dire pourquoi?
Merci d'avance!

Parceque l'UC est utilisé à 100% ?

oui mais j'ai mal formulé ma question comment puis je faire pour que celle-ci soit moins solicité!
 
Est-ce dû à Java ou à mon style de prog???

Essaye sur un quadri-proc  

non sérieusement cela le fait à vous aussi?

De quoi ? Qu'un programme qui a besoin de 100% du CPU prennet 100% du CPU ? Oui.
 
Dans le même temps, je préfère un programme qui prenne 100% pendant une seconde pour se lancer que 1% pendant 1 minute 40 pour la même chose

non il prend 100% pendant tte la durée de son exécution!!!

 
c'est moins normal. Tu aurais pas mis une attente active dans unh coin ?

c quoi une attente active?

Bon, fait péter le code

tu déconnes y'en a des pages et des pages!
mais bon voilà juste le menu :
 
import java.sql.Driver;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.awt.*;    //permet de gerer les parties graphiques
import java.awt.event.*;   //permet la gestion des evenements du clavier et de la souris
import java.util.*;    //permet de declarer les variables temporelles
import java.io.*;  //pour IOException et pour executer de programme
import java.lang.*;  
//on importe les classes crées
import texte;
import recup_ds_txt;
 
 
 
public class menu extends Frame  
{
 static int val;
 static Frame f = new Frame("Première récupération" );
 static Label lab = new Label("                                        Première récupération                                        " );
 static Runtime runtime = Runtime.getRuntime();
 static Process p = null;
 static Process pp = null;
 static Process ppp0,ppp1,ppp = null;
 static String inputLine;
 static BufferedReader in;
 static BufferedReader inn;
 static int nbre_maj=0;
 static String root="";
/**************************************************************************************************/
 
// Le constructeur de la classe menu
 public menu() throws Exception, IOException
 {
  //on definit les actions des boutons
  Button exit = new Button("Exit" );
  exit.addActionListener(new ActionListener()  
  {public void actionPerformed(ActionEvent event)  
   {if (p != null) p.destroy();
   if (pp != null) pp.destroy();
   System.exit(0);}
  });
  Button now = new Button("Récupération" );
  now.addActionListener(new ActionListener()  
  {public void actionPerformed(ActionEvent event)  
   {val = 2;}
  });
  Button stop = new Button("Pause" );
  stop.addActionListener(new ActionListener()  
  {public void actionPerformed(ActionEvent event)  
   {if (val == 1) val = 0;
   else val = 1;};
  });
  Button config = new Button("Paramètres" );
  config.addActionListener(new ActionListener()  
  {public void actionPerformed(ActionEvent event)  
   {try{
    System.out.println("Modification des paramètres" );
    runtime.exec("rundll32 SHELL32.DLL,ShellExec_RunDLL " + root+"\\system32\\cmd.exe /K" + "C:\\Projey_reso\\parametres.bat" );}catch(IOException io){}}
  });
  Button optim = new Button("Optimisation" );
  optim.addActionListener(new ActionListener()  
  {public void actionPerformed(ActionEvent event)  
   {try{
    System.out.println("Optimisation des tables" );
    runtime.exec("rundll32 SHELL32.DLL,ShellExec_RunDLL " + root+"\\system32\\cmd.exe /K" + "C:\\Projey_reso\\optim.bat" );}catch(IOException io){}}
  });
  Button update = new Button("Eléments" );
  update.addActionListener(new ActionListener()  
  {public void actionPerformed(ActionEvent event)  
   {try{runtime.gc();
    System.out.println("Mise a jour des elements qui ne sont pas dans la table elements" );
    //pp = runtime.exec("update_elements.exe" );
    pp=runtime.exec("rundll32 SHELL32.DLL,ShellExec_RunDLL " + root+"\\system32\\cmd.exe /K" + "C:\\Projey_reso\\update_elements.bat" );
 
    inn = new BufferedReader(new InputStreamReader(pp.getInputStream()));
    while ((inputLine = inn.readLine()) != null)
    System.out.println(inputLine);
    inn.close();
    System.out.println("" );
    pp.destroy();}
   catch(IOException io){}}
  });
  f.addWindowListener(new WindowAdapter()  
  {public void windowClosing(WindowEvent event)  
   {if (p != null) p.destroy();
   if (pp != null) pp.destroy();
   System.exit(0);}
  });
  f.setLayout(new BorderLayout());
  Panel pnorth = new Panel();
  Panel pcenter = new Panel();
  Panel psouth = new Panel();  
  pcenter.add(stop); // On ajoute le bouton dans la fenêtre
  pcenter.add(now); // On ajoute le bouton dans la fenêtre
  pcenter.add(config); // On ajoute le bouton dans la fenêtre
  pcenter.add(optim); // On ajoute le bouton dans la fenêtre
  pcenter.add(update); // On ajoute le bouton dans la fenêtre
  pcenter.add(exit); // On ajoute le bouton dans la fenêtre
  psouth.add(lab);// On ajoute le texte dans la fenêtre
  f.add(pnorth,BorderLayout.NORTH);
  f.add(pcenter,BorderLayout.CENTER);
  f.add(psouth, BorderLayout.SOUTH);
  f.pack(); // on ajuste la fenêtre
  f.show(); // On affiche la fenêtre
 }
 
/**************************************************************************************************/
 static public void main(String argv[]) throws IOException, Exception
 {
  //declaration des variables  
  int sec;
  int min;
  int h;
  int jour;
  int mois;
  int annee;
  int day;
  int heure_save;
  int min_save;
  int sec_save;
  int diff_h;
  int diff_min;
  int diff_sec;
  int heure_debut;
  int heure_fin;
  int jour_debut;
  int jour_fin;
  int nbre_adresse;
  int numero_de_ligne;
  int nbre_port;
  int val_old = 0; //sauvegarde de val
  int minuit = 0; //indicateur pour savoir si minuit est passe (permet de dire que 23h < 00h)
  int change_heure = 0; //indicateur pour savoir si on est dans une nouvelle journee
  int para_respect = 1; //indicateur pour la mise a jour de l'affichage de l'heure de recuperation
  String sem;
  String [] semaine = new String[7];
  semaine[0] = "Dimanche";
  semaine[1] = "Lundi";
  semaine[2] = "Mardi";
  semaine[3] = "Mercredi";
  semaine[4] = "Jeudi";
  semaine[5] = "Vendredi";
  semaine[6] = "Samedi";
  val = 0;
  root=argv[0];
   
   
  //BDD
  ResultSet curseur;
  Connection con=null;
  Statement stmt;
  int nb_process=0;
   
   
  /**************************************************************************************/
  //connection à la base
     try  
       {
     Class.forName ( "sun.jdbc.odbc.JdbcOdbcDriver" );
     System.out.println ( "MySQL Driver Found" );
       }  
   catch ( java.lang.ClassNotFoundException e )  
       {
     System.out.println("MySQL JDBC Driver not found ... " );
       }
     
   try  
       {
     System.out.println("debut connection" );
     con = DriverManager.getConnection("jdbc:odbc:reseau","root","" );
     //String den=System.getproperty("windows.windir" );
     //System.out.println("Connection established "+den);
    }
   catch ( java.sql.SQLException e )  
       {
     System.out.println("Connection couldn't be established " );
       }
       
   try
       {
        String sql= "UPDATE admin SET nb_process=0;";
     stmt = con.createStatement();
     stmt.execute (sql);        
     stmt.close ();
       }
   catch (SQLException e)  
       {
     System.out.println ( "Error executing sql statement" );
       }
       
       
  /*****************************************************************/  
   
  new menu();
 
  //condition de demarage
  while (val != 2)
  {
  //declaration et initialisation des variable temporelles
  java.util.Date aujourd = new Date();
  sec = aujourd.getSeconds();
  min = aujourd.getMinutes();
  h = aujourd.getHours();
 
  String minute="";
  if (min<10)
   {
    minute="0"+min;
   }
  else minute=""+min;
  String seconde="";
  if (sec<10)
   {
    seconde="0"+sec;
   }
  else seconde=""+sec;
  //on affiche les parametres dans la fenetre graphique
  f.setTitle(""+h+":"+minute+":"+seconde+"" );
  lab.setText("                          Cliquer sur -Récupération- pour démarrer" );
  }
  val = 0;
  /**************************************************************************************/
 
  //initialisation des variables temporelles
  Date aujourdhui = new Date();
  sec = aujourdhui.getSeconds();
  min = aujourdhui.getMinutes();
  h = aujourdhui.getHours();
 
  //on initialise la prochaine saisie a l'heure actuelle
  sec_save = aujourdhui.getSeconds();
  min_save = aujourdhui.getMinutes();
  heure_save = aujourdhui.getHours();
  /**************************************************************************************/
 
  //on lance la requete de mise a jour de la table resultats
  runtime.gc();
  System.out.println("execution de la mise à jour" );
   
  ppp=runtime.exec("rundll32 SHELL32.DLL,ShellExec_RunDLL " + root+"\\system32\\cmd.exe /K" + "c:\\Projey_reso\\requete_maj.bat ASC" );
 
   
 
  /**************************************************************************************/
 
  //on va chercher dans le fichier "parametres.txt" les conditions de recuperation des compteurs
  int [] para_d = new int[7];
  para_d = recup_ds_txt.parametre_temp("parametres.txt" );
 
  diff_h = para_d[0];
  diff_min = para_d[1];
  diff_sec = para_d[2];
 
  //mise a jour de l'heure de la prochaine saisie
  sec_save = sec_save + diff_sec;
  if (sec_save >= 60)
  {sec_save = sec_save - 60;
  min_save = min_save + 1;}
  min_save = min_save + diff_min;
  if (min_save >= 60)
  {min_save = min_save - 60;
  heure_save = heure_save + 1;}
  heure_save = heure_save + diff_h;
  if (heure_save >= 24) heure_save = heure_save - 24;
 
  lab.setText("                          Prochaine récupération à "+heure_save+":"+min_save+":"+sec_save);
  /**************************************************************************************/
  for(;
  {
   Date a = new Date();
   sec = a.getSeconds();
   min = a.getMinutes();
   h = a.getHours();
   f.setTitle(""+h+":"+min+":"+sec+"" );
   if (val == 1) val_old = 1;
   if (val == 0) val_old = 0;
   while(val != 1)
   {
    /**************************************************************************/
    Date today = new Date();
    sec = today.getSeconds();
    min = today.getMinutes();
    h = today.getHours();
    jour = today.getDate();
    mois = today.getMonth();
    annee = today.getYear();
    day = today.getDay(); //0=dimanche 1=lundi 2=mardi 3=mercredi 4=jeudi 5=vendredi 6=samedi
    mois=mois+1; //le mois 0 corespond au mois de janvier
    //annee=annee-100; //l'an 00 corespond a 1900
 
 
    //on affiche les parametres dans la fenetre graphique
    f.setTitle(""+h+":"+min+":"+sec);
     /**************************************************************************/
 
    //on va chercher dans le fichier "parametres.txt" les conditions de recuperation des compteurs
    int [] para = new int[7];
    para = recup_ds_txt.parametre_temp("parametres.txt" );
    diff_h = para[0];
    diff_min = para[1];
    diff_sec = para[2];
    heure_debut = para[3];
    heure_fin = para[4];
    jour_debut = para[5];
    jour_fin = para[6];  
 
    //on reajuste l'heure de la prochaine saisie (au cas ou on en ait manque une)
    while ((minuit == 0 && heure_save < h) || (minuit == 0 && min_save < min && heure_save <= h) || (minuit == 0 && sec_save < sec && min_save <= min && heure_save <= h))
       {
     sec_save = sec_save + diff_sec;
     if (sec_save >= 60)
     {sec_save = sec_save - 60;
     min_save = min_save + 1;}
     min_save = min_save + diff_min;
     if (min_save >= 60)
     {min_save = min_save - 60;
     heure_save = heure_save + 1;}
     heure_save = heure_save + diff_h;
     if (heure_save >= 24)  
     {heure_save = heure_save - 24;
     minuit = 1;}
     change_heure = 1;
    }
 
    if (change_heure == 1)  
    {lab.setText("                          Prochaine récupération à "+heure_save+":"+min_save+":"+sec_save);}
    change_heure = 0;
    if (h == 0 && min == 0 && sec == 0) minuit = 0;
    if (heure_save < heure_debut || heure_save >= heure_fin || day < jour_debut || day > jour_fin)
    {
     if (day <= jour_fin && day >= jour_debut) sem = semaine[day];
     else sem = semaine[jour_debut];
     lab.setText("                          Reprise de la récupération : "+sem+" après "+heure_debut+" heures." );
     para_respect = 0;
    }
 
    if ((para_respect == 0) && (h >= heure_debut && h < heure_fin && day >= jour_debut && day <= jour_fin))
    {
     lab.setText("                          Prochaine récupération à "+heure_save+":"+min_save+":"+sec_save);
     para_respect = 1;
    }
    /**************************************************************************/
    //condition qu'on est bien dans l'intervale de temps que l'on a defini
    if ((h >= heure_debut && h < heure_fin && day >= jour_debut && day <= jour_fin) || val == 2)
    {
     //condition que l'heure corresponde a la fin de la temprisation
     if((h == heure_save && min  == min_save && (sec-sec_save>=0)) || val == 2)
     {
      try
          {
           String sql= "SELECT nb_process FROM admin;";
        stmt = con.createStatement();
        ResultSet RS=null;
        RS=stmt.executeQuery(sql);
        RS.next();
        nb_process=RS.getInt("nb_process" );
        stmt.execute (sql);        
        stmt.close ();
        System.out.println("courcour" );
          }
      catch (SQLException e)  
          {
        System.out.println ( "Error executing sql statement" );
        //throw ( e );
          }
       
      if (nb_process<2){
      heure_save = h;
      min_save = min;
      sec_save = sec + diff_sec;
      if (sec_save >= 60)
      {sec_save = sec_save - 60;
      min_save = min_save + 1;}
      min_save = min_save + diff_min;
      if (min_save >= 60)
      {min_save = min_save - 60;
      heure_save = heure_save + 1;}
      heure_save = heure_save + diff_h;
      if (heure_save >= 24)  
      {heure_save = heure_save - 24;
      minuit = 1;}
      val = val_old;
      /***************************************************************/
      f.setTitle("récupération à : "+h+":"+min+":"+sec+"" );
      lab.setText("                          Prochaine récupération à "+heure_save+":"+min_save+":"+sec_save);
      runtime.gc();
        p=runtime.exec("rundll32 SHELL32.DLL,ShellExec_RunDLL " + root+"\\system32\\cmd.exe /K" + "C:\\Projey_reso\\recuperation.bat" );
 
      //p = runtime.exec("recuperation.bat" );
      in = new BufferedReader(new InputStreamReader(p.getInputStream()));
      while (((inputLine = in.readLine()) != null) && ((minuit == 0 && heure_save > h) || (minuit == 0 && min_save > min && heure_save <= h) || (minuit == 0 && sec_save > sec+3 && min_save <= min && heure_save <= h)))
      {
       Date ad = new Date();
       f.setTitle(""+h+":"+min+":"+sec);
       sec = ad.getSeconds();
       min = ad.getMinutes();
       h = ad.getHours();
       System.out.println(inputLine);
      }
      in.close();
      //p.destroy();
 
      //on lance la requete de mise a jour de la table resultats
      runtime.gc();
       switch(nbre_maj)
  {
   
  case 0 : //aucune maj n'a été lancée on en lance une
   ppp.destroy();
   ppp0=runtime.exec("rundll32 SHELL32.DLL,ShellExec_RunDLL " + root+"\\system32\\cmd.exe /K" + "c:\\Projey_reso\\requete_maj.bat ASC" );
   nbre_maj++;
   break;
   
  case 1 : //une maj a déjà été lancée on en relance une mais elle parcourt les valeurs à mettre à jour dans le sens decroissant pour ne pas gener la maj 0
   ppp1=runtime.exec("rundll32 SHELL32.DLL,ShellExec_RunDLL " + root+"\\system32\\cmd.exe /K" + "c:\\Projey_reso\\requete_maj.bat DESC" );
   nbre_maj++;
   break;
  case 2:
   //on detruit les deux maj precedente et on en recrée une qui va finir le travail des deux si elles n'ont pas déjà fini
  ppp0.destroy();
  ppp1.destroy();
  nbre_maj=1;
     ppp0=runtime.exec("rundll32 SHELL32.DLL,ShellExec_RunDLL " + root+"\\system32\\cmd.exe /K" + "c:\\Projey_reso\\requete_maj.bat ASC" );
   break;
  }
 
     }
     else {
      min_save=min_save+1;      
      if (min_save >= 60)
       {
        min_save = min_save - 60;
        heure_save = heure_save + 1;
       }
        heure_save = heure_save + diff_h;
        if (heure_save >= 24)  
         {
          heure_save = heure_save - 24;
          minuit = 1;
         }
      }
    }}  
    if (val == 1) lab.setText("                          Récupération interrompue" );
    if (val != 1) lab.setText("                          Prochaine récupération à "+heure_save+":"+min_save+":"+sec_save);
   }
  }
 }
}
 
Merci de ton aide

 
C'est quoi cette chose ?

c'est un affichage de l'heure sur la fenêtre!
même si je l'enlève ça rame!

Bon, je vais être dur, mais il va falloir être fort : ton code est nul.
 
Aucune structuration, des préceptes objets foulés au pieds, mauvaise utilisation des notions de temps, gestion  d'erreur cacateuse, grand n'importe quoi avec les executions externes...
 
Chercher à juste s'occuper du fait qu'il prennet 100% du temps CPU, c'est ne s'interresser qu'a un seul symptome d'une maladie beaucoup plus large. C'est comme donner une pommade contre l'acrnée à quelqu'un qui a la rougeole.

vas te faire foutre! comment peux tu analyser un code localement alors que tu connais pas le reste!
 
dis plutôt que tu vois pas de solution cela serait plus honnête!
les notions de temps sont gérées de façon nickel!!!
 
 
Pfff trouve une sol alors...
Les exceptions sont gérées pour ne pas être affichées, pas d'indentation c normal avec le copier coller!

 
VIeux proverbe : si c'est moche à un endroit au hasard, il y a de fortes chances que ce soit moche partout.
 

 
Avec des attentes actives ? C'est pas ce que j'appelerais nickel.
 

 
Sont pas gérées quoi. J'aime bien les programmes qui ne disent rien en vcas de problème, c'est sympa pour comprendre le problème.
 

 
Oui, mais non, c'est même pas indenté sur les conventions java, même avec le ruinage du au copier coller, ça se voit.

j'indente jamais mon code que ça te dérange ou non pas de gestion d'erreurs car c un code qui devra travailler en permanence et je veux pas que les utilisateurs voient qd il y a une erreur qui ne gêne en rien le fonctionnement du reste du prog!!!!
 
 
et puis c quoi una attente active j'attends tjrs la réponse!

note c un code que je viens de reprendre alors laisses au moins le droit à l'inconnu qui l'a réalisé de se défendre!

 
J'espère que celui qui l'a écrit a été viré pour faute lourde et crime contre l'humanité

 
félicitation, tu viens de rentrer dans les fortunes

l'attente active est forcée car c un code qui agît tt seul!
 
sinon toi tu fais quoi ds la vie?

 
 
enocre une fois c une analyse locale d'une phrase non prise ds sa globalité : tu serais pas journaliste à TF1 toi?

 
J2EE Lead Architect

Sans être méchant ton code c'est une catastrophe.
Essaye d'abord de séparer ton code en plusieurs méthode, ca sera déjà plus lisible.
Ensuite ne gère pas les exceptions en affichant juste un message d'erreur et en laissant le programme continuer. Par exemple si le driver JDBC n'est pas trouvé ton programme continue quand même, ce n'est pas normal...
Essaye de donner des noms lisibles et comprehensible à tes variables, si possible en respectant les conventions de nomage Java.
 
Pour ton problème, il doit y avoir une boucle infinie qq part. Si tu ne vois pas ou, affiche des messages dans ton code et tu vera à l'éxécution si un message est affiché en continu.

y'a pas de boucles infinies et puis si j'aime écrire un bordel c mon pb!
le prog doit tourner en permanence car il effectue des récupération ds la mib ttes les x min (def par l'utilisateur). et ça marche très bien!
 
le pb du driver et géré ds un autre bout de code!
et y'a d'autres fonctions ailleurs
 
répondez au pb mais pas ailleurs ça sert à rien!

 
Le problème vient peut être de là.
C'est tellement le bordel que tu es incappable de voir ce qui bouffe ta CPU. Si le code était plus clair le problème te sauterait surement aux yeux.
En tout cas moi ca ne me donne pas envie de regarder plus que ça...

Dans la mesure ou cela ne semble pas être un programme écrit par toi uniquement pour toi, non, c'est pas ton pblm. Ton pblm c'est de laisser un code facile à maintenir. Ca te vexe, mais comme on dit, y'a que la vérité qui blesse. T'as beau dire ce que tu veux, ton code est illisible.
En ce qui me concerne, la partie la plus obscure et surement celle responsable de ton probleme est celle-ci :

bon ben je vais trouver des personnes plus comptétentes!
c bout de code mets 2s pas plus et n'est génant en aucune sorte!
 
le fait que ça rame c de faire tourner le prog en permanence : il est automatique, il attend l'instant t pour exécuter un traitement dc il tourne continuellement!

Bon j'ai regardé un peu et je pense comme Kadreg.
Le bout de code qu'il t'a montré bouffe 100% de CPU tant que tu n'a pas cliqué sur ton bouton, uniquement pour mettre à jour la date. Si tu rajoutait un piti Thread.sleep(100) dans ta boucle ca serait deja mieux.

Et puis bon si je puis me permettre, un programme qui tourne continuellement n'est pas obligé d'utilisé 100% de CPU et heureusement.

ce serait dommage en effet...

Bonne idée, va donc voir ailleurs!

je crois sans vouloir te vexer que t un pauvre type 23samael ...
 
Je me préente, Jubijub, débutant en java...
 
Ben même en étant un noob, je m'en voudrais de sortir du code de merde comme ca...
- je me demande bien pkoi tt les variables sont en statique au début...les getters/setters tu connais ? c un peu une base de la POO, l'encapsulation...
- tes noms de variables sont à chier, la présenation du code aussi...qd tu fais du java, le minimum c de respecter les conventions java...
- tt ton programme dans le main : je rigole...
- gestion des exceptions : même si tu veux pas que l'utilisateur les voie, tu pourrais les logger...et pis certaines doivent faire arreter le programme, parce que si tu continues ca va devenir franchement incohérent...
 
bref, au lieu de t'insurger qd les gens disent que ton code pue, regarde....surtout les traiter d'incompétentes c fort, sachant que c présisément une preuve de compétence de trouver ton code à chier
 
regarde, de l'aide pour toi :
http://java.sun.com/docs/books/tutorial/

Je ne comprends pas que vous perdiez votre temps avec lui avec quelqun qui répond ça :
 

 
Mon pti gars, ton code source est vraiment pas terrible.  
J'espère bien que tu iras voir ailleurs et qu'on te le répétera. C'est ce qui peut t'arriver de mieux.

IWH /o\
 
23samael> va te faire enculer

Bah mince alors il a retiré le code !!!
Comment on va rire maintenant ??

sauvegarde:

ben non il est pas retiré ?

 
*schbam*

il aurait dir :  
 
un serial killer, ca aurait pas sonné différement