controllo esecuzione dopo thread

[foxmolder5]

in un ciclo while ho inserito l'avvio di un thread.all'interno del thread vengono eseguite determinate operazioni.vorrei che si andasse avanti con le istruzioni, e quindi si passasse anche da un ciclo a quello successivo solo al termine delle operazioni all'interno del thread.così da non permettere che si accavallino le esecuzioni.come posso fare?grazie

[kingv]

THread ha un metodo che si chiama join() che fa fermare l'esecuzione aspettando la "morte" del thread su cui viene chiamato.

Penso che sia quello di cui hai bisogno, nel thread "istanziatrore" lo puoi chiamare per aspettare che il figlio termini prima di andare avanti nell'esecuzione.

[foxmolder5]

non ho thread che a sua volta chiamano thread.ti spiego.ho un ciclo while e al suo interno un ciclo for che crea i thread.io vorrei fare in modo che prima che inizi un nuovo ciclo while tutti i thread abbiano finito di lavorare,altrimenti avrei 1 casino.grazie

[kingv]

puoi risolvere così:


//nel processo principale
//mettiamo che la tua classe thread si chiami MyThread

ThreadGroup tg = new ThreadGroup("TG");
for(int i = 0 ; i<10 ;i++)
{
MyThread mt = new MyThread(tg);
mt.start();
}

while(tg.activeCount()>0)
Thread.currentThread().yield();

[foxmolder5]

mi spieghi come funziona ciò che hai scritto e cosa sono le funzioni activateCount e Yeld?sai sono alle prime armi e quindi devo ancora documentarmi bene su certe cose.grazie mille x l'aiuto.

[Luc@s]

// il gruppo dei thread da eseguire
ThreadGroup tg = new ThreadGroup("TG");
for(int i = 0 ; i<10 ;i++)
{
// inserisce mt nel dominio del gruppo di thread
MyThread mt = new MyThread(tg);
// lo esegue
mt.start();
}
// finche il numero de thread attivi è maggiore di 0 finito il thread
// corrente passa il controllo al successivo
while(tg.activeCount()>0)
Thread.currentThread().yield();




è cosi o sbaglio?

[foxmolder5]

il codice dovrebbe essere così:

while (a == true){
//nel processo principale
//mettiamo che la tua classe thread si chiami MyThread

ThreadGroup tg = new ThreadGroup("TG");
for(int i = 0 ; i<10 ;i++)
{
MyThread mt = new MyThread(tg);
mt.start();
}

while(tg.activeCount()>0)
Thread.currentThread().yield();
}

con questo codice se ho capito bene in ogni ciclo vengono avviati 10 thread.si passerà la ciclo while successivo (la condizione del while l'ho scritta a caso) soltanto quando tutti i thread avranno finito di lavorare,e la fine di tutti sarà determinata dal while che hai inserito tu.è così?

[foxmolder5]

ho provato il codice ma mi sono accorto di una cosa.preferirei non avere il thread tg perchè altrimenti incasinerei 1 pò troppo le cose.non sarebbe meglio condice di controllo che interagisca direttamente con i thread mt?

[kingv]

Originariamente inviato da Luc@s
è cosi o sbaglio?


perfetto ;)

[kingv]

Originariamente inviato da foxmolder5
ho provato il codice ma mi sono accorto di una cosa.preferirei non avere il thread tg perchè altrimenti incasinerei 1 pò troppo le cose.non sarebbe meglio condice di controllo che interagisca direttamente con i thread mt?


e' una possibile soluzione ma te la sconsiglio, controllare i songoli thread (al posto che il threadGroup) ti costringerebbe a delle sleep() nel thread principale che non hanno senso.

[foxmolder5]

risolto ma devo perfezionare il tutto.ho creato una variabile statica.quando avvio 1 thread si incrementa di 1 quando termina si decrementa.si passa al ciclo successivo solo se la variabile è uguale a 0.una domanda ma se dichiaro synchronized un metodo e poi anche un pezzo di codice esterno al metodo la sincronizzazione avviene anche tra questi due?perchè a me interesserebbe rendere la sincronizzazione separata nel senso che mi interessa che non venga eseguito contemporaneamente quel metodo da + di 1 thread alla volta e ("e" non inclusivo) che un thread alla non svolga quel pezzo di codice.

[Luc@s]

Originariamente inviato da kingv
perfetto ;)

Tannenbaum docet :D

[kingv]

Originariamente inviato da foxmolder5
risolto ma devo perfezionare il tutto.ho creato una variabile statica.quando avvio 1 thread si incrementa di 1 quando termina si decrementa.


va bene anche questo come approccio.
del discorso del synchronized non ho capito un tubo :confused:
fai un esempio

[foxmolder5]

public class ciao extends Thread {
.......
public void synchronized salve() {}


...............

public static void main..............{
synchronized(this) {
...............
}
}
}


con tale codice sono sincronizzati il metodo salve ed il codice contenuto dentro alle parentesi del synchronized del main?per io uso il synchronized per permettere ad una sola applicazione alla volta di accedere al metodo o parte di codice (quello nel main) e quindi mi darebbero problemi i synchronized "comunicanti".

[kingv]

sinceramente mi sembra di ricordare che esiste un unico lock a livello di istanza, per cui nel tuo caso i due synchronized potrebbero essere acceduti uno per volta.

potrei sbagliarmi, appena ho tempo mi vado a documentare ;)