Esce dal while dopo chiamata di funzione, perché?

[andbaz]

Ho un ciclo infinito di tipo while, se ad un certo punto risultano vere certe condizioni manda in esecuzione una funzione "loop"...ma perché il ciclo infinito mi si ferma? Io vorrei farlo poter continuare, anche con l'esecuzione di una funzione. Come posso risolvere? (Sto traducendo un codice javascript in java, e questo tipo di problema non esisteva...è normale che funzioni così java? Vorrei trovare una soluzione! Grazie)

    
    public static void main(String[] args) {

         while(true) {

             if (k == false)
                loop(i);

// Se mi se esegue loop(i) questo ciclo non prosegue più e si ferma quando invece io vorrei continuarlo a farlo girare per la verifica delle condizioni ma su altri elementi di un array ecc.

             try {
                Thread.sleep(div);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         
    }
    
    public static Object loop(int x) {
        int j = 0;
        int l = 100;
        while(true) {            
               try {
               Thread.sleep(div);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           j++;
           if (j == l) return loop(x);
        }
    }
}

[andbin]

    
    public static Object loop(int x) {
        int j = 0;
        int l = 100;
        while(true) {            
               try {
               Thread.sleep(div);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           j++;
           if (j == l) return loop(x);
        }
    }

Quello che vedo è che loop è "ricorsivo" (invoca sé stesso). Siccome j parte da 0 e si incrementa ad ogni ciclo, ad un certo punto sicuramente arriverà a 100, quindi con il j == l "true", farà return loop(x). Ma invocando ricorsivamente loop, tutto il discorso si ripete. Ad un certo punto lo stack ... esplode (= ti becchi StackOverflowError).

Più che far vedere il codice, dovresti spiegare cosa vuoi realizzare e con quali obiettivi.

P.S. e forse è meglio dirlo: questo metodo loop ha poco/nessun senso. Non ritornerà mai qualcosa di concreto!

[Renny]

Non è più semplice così?

 while(j<=l){ 
try {
    Thread.sleep(div);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
j++;
}
return loop(x);
}

Ho messo "return loop(x);" perché non so cosa vuoi fare, ma non so se è corretto

[andbaz]

No un attimo: io mi riferivo al primo ciclo, vorrei farli poter ciclare entrambi insieme, in javascript mi andava e a livello di prestazioni funzionava anche bene tutto sommato. Qui alla chiamata loop(i) mi esce dal primo e passa al secondo, come posso risolvere? Al di là di cosa serva il codice...lo ho sintetizzato per semplificare il mio caso per cui è solo un esempio del mio codice originario.

[francesco.muia]

Che quei due cicli while ti venissero eseguiti parallelamente in javascript mi sembra veramente impossibile dato che js e mono thread e non hai nessun modo di lanciare altri thread ( a parte usare i background worker inseriti nella specifica html 5). Comunque se vuoi che i due cicli vengano eseguiti in modo parallelo devi mettere il secondo while dentro il run di un Java.lang.Thread e ovviamente gestire lo start di questo nel primo while.

[andbaz]

Ho risolto così dentro il main unendo i due cicli ed eliminando la funzione loop, questo è il mio codice vero e proprio: fa quello che deve fare, ma in quanto a prestazioni...ha senso secondo voi come cosa?

           while(true) {
             for (int i = 48; i < 58; i++) {
                 if (startLoop[i] == true) {
                     len[i] = num[i].length;
                     if (num[i][j[i]] != 0) {
                           snd[num[i][j[i]]].stop();
                         snd[num[i][j[i]]].setFramePosition(0);
                         snd[num[i][j[i]]].start();
                     }
                        j[i]++;
                        if (j[i] == len[i]) {
                            j[i] = 0;
                        }
                 }
             }
             try {
                 Thread.sleep(div);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }

[andbaz]

Forse è il caso che vi spieghi il senso di questo ciclo while(true): si trova nel main, creato per ciclare all'infinito. Il for (int i = 48; i < 58; i++) è creato invece per sondare diciamo 10 contenitori, il cui contenuto, se il relattivo array booleano startLoop[i] è uguale a true, non è altro che un array di dimensione variabile: se uno di questi è diverso da zero, prendo il suo valore n e lo riproduco come suono n.wav. Incremento il relativo j[i]++, cioè passo al valore successivo dell'array contenuto in uno dei 10 contenitori. Continuo a sondare questo array finché non termina la sua lunghezza per poi farlo ripartire dall'inizio: if (j[i] == len[i]) j[i] = 0; Tutto questo vorrei poterlo fare in 1 centesimo di secondo (div = 10), male che vada a livello prestazionale 1 decimo di secondo (div = 100). E' questo il punto, ha senso come cosa o mi esplode tutto ad un certo punto? (Prendete in considerazione il caso pessimo: tutti i 10 contenitori sono attivi, cioè startLoop[i] == true: ciclerebbero tutti in pochissimo tempo, scorrendo i propri array un valore dopo l'altro riproducendo i suoni nel giusto istante di tempo).

In javascript avevo adottato a dire il vero non più while, ma più setInterval...e non avevo considerato il contenuto dei contenitori come array ma come stringhe e le scorrevo come in questo caso: sarebbe una soluzione migliore?

GRAZIE


Codice uguale a quello del post di prima.

         while(true) {
             for (int i = 48; i < 58; i++) {
                 if (startLoop[i] == true) {
                     len[i] = num[i].length;
                     if (num[i][j[i]] != 0) {
                           snd[num[i][j[i]]].stop();
                         snd[num[i][j[i]]].setFramePosition(0);
                         snd[num[i][j[i]]].start();
                     }
                        j[i]++;
                        if (j[i] == len[i]) {
                            j[i] = 0;
                        }
                 }
             }
             try {
                 Thread.sleep(div);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }

[andbaz]

UP

[andbaz]

The last UP