Calcolo parametrico multiprocesso

[Lory1990]

Ciao a tutti! Ho scritto un codice e adesso devo farlo girare più volte con parametri diversi! Dato che dovrò fare tanti calcoli ho pensato di scrivere questo codice:

  try{ Stream.PrintTitle(language.getString("START_PARAMETRIC_SIMULATION")); } catch(Exception e){}
        Executor = Executors.newFixedThreadPool(3);
        //ArrayList<DeterministicSinkSimulation> Deterministic = new ArrayList<>();
        double Lengths[]       = content.getLength().getDiscreteValues();
        double Heights[]       = content.getCenterHeight().getDiscreteValues();
        double Penetrations[]  = content.getPenetration().getDiscreteValues();
        double CenterLenghts[] = content.getCenterLongitudinal().getDiscreteValues();
        double CenterHeights[] = content.getCenterHeight().getDiscreteValues();
        int j = 0;
        try{ Stream.PrintSubSubTitleCenter("Pool");} catch(Exception e){}
        for (double Length  : Lengths) {
            for (double Height : Heights) {
                for (double Penetration : Penetrations) {
                    for(double CenterLenght : CenterLenghts){
                        for (double CenterHeight : CenterHeights) {
                            DeterministicSinkSimulation D = new DeterministicSinkSimulation();
                            /* Riempio la classe e mando all'executor*/
                           Executor.submit(new Calculations(D,j));
                            //Deterministic.add(D);
                            if(j==9){
                                Executor.shutdown();
                                while(!Executor.isTerminated()){
                                    if(Stop) Executor.shutdownNow();
                                    Executor.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
                                }
                                Executor  = Executors.newFixedThreadPool(3);
                                try{ Stream.PrintSubSubTitleCenter("Pool");} catch(Exception e){}
                                System.gc();
                                j=0;
                            }else{
                                j++;
                            }
                        }
                    }
                }
            }
        }
        Executor.shutdown();
        while(!Executor.isTerminated()){
            if(Stop) Executor.shutdownNow();
            Executor.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
        }
    }

e la Classe calculations è fatta così

private class Calculations implements Runnable{


        private DeterministicSinkSimulation DSC;
        private final int Index;        
        
        public Calculations(DeterministicSinkSimulation DSC, int Index) {
            this.DSC     = DSC;
            this.Index   = Index;
        }
        
        @Override
        public void run() {
            if(Thread.currentThread().isInterrupted()) return;
            try{
                StreamSemaphore.acquire();
                try{ Stream.Println(language.getString("STARTING_CALCULUS") + " " + (Index+1), Color.BLUE); } catch(Exception e){}
                StreamSemaphore.release();
            }catch(Exception e){}
            SinkSimulation.SingleCalculation C = new SinkSimulation.SingleCalculation(DSC);
            try{
                C.Calculate();
                DSC.clearUselessData();
                DSC.setCalculated(true);
                try{Progress.addValue(1);} catch(Exception e){}
                WriteFile(DSC);
                try{
                    StreamSemaphore.acquire();
                    try{ Stream.Println(language.getString("ENDED_CALCULUS") + " " + (Index+1), Color.GREEN); } catch(Exception e){}
                    StreamSemaphore.release();
                }catch(Exception e){}
            }catch(Exception e){
                Exception = e;
                try{
                    StreamSemaphore.acquire();
                    try{ Stream.Println(language.getString("ERROR_ON_CALCULUS") + " " + (Index+1) + ": " + e.getMessage(), Color.RED); } catch(Exception ex){}
                    StreamSemaphore.release();
                }catch(Exception ex){}
            }
        }
        
        private Exception Exception = null;


        public Exception getException() {
            return Exception;
        }
        
        private void WriteFile(DeterministicSinkSimulation SC){
               /** Write on file */
        }
    }

Il problema è che ad un certo punto tutto si ferma e non va più avanti! che problema può essere?

EDIT non c'è un messaggio di errore... a me sembra che il programma mantenga tutto in RAM e quindi ad un certo punto non abbia più ram per fare i conti

[Alex'87]

Se non ci fosse più memoria disponibile otterresti un OutOfMemoryError...

Tra l'altro stai gestendo le eccezioni nel modo peggiore in assoluto! catch (Exception e) { } è un ottimo modo per rendere impossibile il debug (per forza poi il programma non ti stampa errori, uccidi l'eccezione!)

Se dici che ad un certo sembra piantato mi sa che sei andato in dead lock.

 
try{
    StreamSemaphore.acquire();
       try{ Stream.Println(language.getString("ENDED_CALCULUS") + " " + (Index+1), Color.GREEN); } catch(Exception e){}
       StreamSemaphore.release();
}catch(Exception e){}

1. Come già detto, pessima gestione delle eccezioni.
2. Non sarebbe meglio usare un finally per fare la release? E' fatto proprio per questo tipo di operazioni

Viene molto più pulito:

try {
  StreamSemaphore.acquire();
  Stream.Println(language.getString("ENDED_CALCULUS") + " " + (Index+1), Color.GREEN);
} catch (Exception ex) {
  System.err.println("Si e' verificato un errore: " + ex);
  ex.printStackTrace(); 
} finally {
  StreamSemaphore.release();
}

3. Cerca di seguire la convezioni standard per la nomenclatura di classi, metodi e variabili.
4. Indenta il codice correttamente
Cose come

 
try{
    StreamSemaphore.acquire();
    try{ Stream.Println(language.getString("ENDED_CALCULUS") + " " + (Index+1), Color.GREEN); } catch(Exception e){}
    StreamSemaphore.release();
}catch(Exception e){}

fanno venire i brividi