je n'arrive pas à exécuter des thread en parallèles

bonsoir tout le monde,

j'ai une classe java qui met bcp de temps pour être exécutée donc je l'ai mise dans un thread java afin d'exécuter d'autres tâches en parallèles.
le problème est que une fois j'instancie cette classe le reste du code n'est axécutée que si cette même classe ait fini son traitement. je ne sais pas du tout comment faire pour pouvoir rendre mes tâches parallèles. j'ai fait pas mal d'essaie avec syncronized, avec la classe Observable (pour detecter les changement des variables dans ma classe en exécution), j'ai essayé de suspendre mon thread rien ca ne marche pas il y'a toujours une exécution séquentielle de mon code.

SVP comment je pourrais faire.
si vous êtes intéréssés je pourrais vous poster les codes

merci

Veux tu bien nous mettre un peu de code pour voir un peu de quoi il s'agit?

ce que je peux rajouter c'est que si tu veux de la concurence il faut que tu sois en possession d'un processeur multicoeur .(je suis pas sûr)

pour syncronized elle permet de verrouiller un objet , cad qu'un thread peut accéder à un objet à la fois.

Bonjour,

La classe SNMP walk est celle qui met beaucoup de temps pour être exécutée, la voilà :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
public class snmpwalk extends Observable
{ 
 static OID targetOID;
 static String targetFile;
 static String SQLTable;
 static String colonne;
 static int compteurJ;
 static boolean finished = false;
 static String nom_fichier;
 
 public snmpwalk(Storage s, OID targetOID, String targetFile) throws IOException
 {
    this.targetOID=targetOID;
    this.targetFile=targetFile;
    new File(targetFile).mkdir();
    this.SQLTable=SQLTable;
    this.colonne=colonne;
  
     
    PDU requestPDU = new PDU();
    requestPDU.add(new VariableBinding(targetOID));
    requestPDU.setType(PDU.GETNEXT);
   
    
    // Create Target Address object
    Address targetAddress = new UdpAddress(s.getRouterAddr()+"/161");
    CommunityTarget target = new CommunityTarget();
    target.setCommunity(new OctetString(s.getCommunity()));
    target.setAddress(targetAddress);
    target.setVersion(SnmpConstants.version2c);
    
    try
    {
      TransportMapping transport = new DefaultUdpTransportMapping();
      Snmp snmp = new Snmp(transport);
      transport.listen();

      int i=0; // indexe chaque ligne affichée
      int j=1; // index le fichier crée contenant 5000 lignes
     
     nom_fichier=String.valueOf(j);
     File fic=new File(targetFile+"/"+nom_fichier);
     FileWriter fw =new FileWriter(fic);
     BufferedWriter bw=new BufferedWriter(fw);
     PrintWriter print=new PrintWriter(bw);
     
      while (!finished)// requête non encore terminée
  {     
        
        VariableBinding vb = null;

        PDU responsePDU = snmp.sendPDU(requestPDU, target);
        if (responsePDU != null)
        {
          vb = responsePDU.get(0);
            
        }

        if (responsePDU == null)
        {
          
          finished = true;
        }
        else if (responsePDU.getErrorStatus() != 0)
        {
          
          System.out.println(responsePDU.getErrorStatusText());
          finished = true;
        }
        else if (vb.getOid() == null)
        {
          
          finished = true;
        }
        else if (vb.getOid().size() < targetOID.size())
        {
          
          finished = true;
           
        }
        else if (targetOID.leftMostCompare(targetOID.size(),
                                           vb.getOid()) != 0)
        {
          this.setFinished(true);
           
         // finished = true;
          
          
            
        }
        else if (Null.isExceptionSyntax(vb.getVariable().getSyntax()))
        {
          
          finished = true;
        }
        else if (vb.getOid().compareTo(targetOID) <= 0)
        {

          finished = true;

        }
        else // à partir d'ici la partie la plus interessente : cette classe inscrit son résultat 
                   // dans plusieurs fichiers contenant chacun 1000 lignes
        { 
           
          // Dump response.
          String [] resultat= (vb.toString()).split("= ");
          print.println(resultat[1]);
          print.flush();
          // Set up the variable binding for the next entry.
          requestPDU.setRequestID(new Integer32(0));
          requestPDU.set(0, vb);
          i++;
        }
        
       if (i==1000)      // si on arive à 1000 lignes on fermes le fichier et on en crée un autre
     {  
        
        this.setFile(String.valueOf(j));
        //nom_fichier=String.valueOf(j);
        System.out.println(nom_fichier); 
        j++;
        fic=new File(targetFile+"/"+nom_fichier);
        fw =new FileWriter(fic);
        bw=new BufferedWriter(fw);
        print=new PrintWriter(bw);
        i=0;
        
         System.out.println("changement de fichier");
     }
 }
       
      snmp.close();
     
    }
    catch (IOException e)
    {
      System.out.println("IOException: "+e);
    }

  }
          
  public String setFile( String nom)
  {
      this.nom_fichier=nom;
      System.out.println("L'instance de snmpwalk a Finished qui passe à "+nom_fichier+" ; elle notifie les observateurs.");
      setChanged();
      notifyObservers(nom_fichier);
      return(nom_fichier);
  }
 public String getFile()
  {
      return(nom_fichier);
  }
 
 public boolean setFinished(boolean finish) // Finished permet de dire que la classe a fini
                                                                // son exécution au complet : j'ai besoin que 
                                                               // cette variable booléénne soit détéctée par
                                                          // mon thread principal pour savoir quand s'arrêter
  {
      this.finished=finish;
      System.out.println("L'instance de snmpwalk a Finished qui passe à "+finished+" ; elle notifie les observateurs.");
      setChanged();
      notifyObservers(finished);
      return(finished);
  }
  public boolean getFinished()
  {
      return(finished);
  }
  
   public static void main(String[] args) throws IOException, Exception {
      snmpwalk s=new snmpwalk(new Storage("10.53.3.150/161", "INTERNET@orange"),new OID(".1.3.6.1.2.1.4.24.4.1.1"),"/root/Desktop/peer");
     
    }
}
 maintenant voici le thread qui utilise cette classe

public class test implements Observer{
    String nom_instance="";
    static snmpwalk walk;
    public test(String s)
    {
        nom_instance=s;
    }
    
    @Override
    public void update(Observable o, Object arg) {
        System.out.println(nom_instance+" vient d'être notifiée que le nom du fichier clos est"+arg);
    }
   public static void main(String[] args) throws Exception {
    
      final test t=new test("test");
      
      Thread th=new Thread()  //thread réservé pour snmpwalk
              
      { public void run()
      {  
      snmpwalk s=new snmpwalk(new Storage("10.53.3.150/161",      "INTERNET@orange"),new OID(".1.3.6.1.2.1.4.24.4.1.1"),"/root/Desktop/peer");
         
      }
      };

Thread th2=new Thread()   // thread réservé pour la tâche s.getFile()
{
  public void run()
    {   System.out.println(s.getFile());   }
}
      th.start();
     th2.start()
    }
}

Je veux que pendant l'exécution de snmpwalk, faire la tâche (s.getFile()) mais malheureusement je n'y arrive pas car snmpwalk ne s'arrête pas que si elle est terminée.

Merci et désolé pour la longueur du message.