Newsgroup: it.comp.java
Titolo: ThrEAD

Ragazzi,
come faccio a creare tanti thread?
cioč ho una classe thread consumatore voglio creare n
thread consumatore.
io ho fatto
consumatore th=new consumatore();
for(int i=0; i<n; i++)
th.start();
ma non funziona errore a run-time.........
Grazie a Tutti
P.S. se quell' n (numero di consumatori) fosse un numero random quale
funzione devo eseguire?


Se n non è un numero random es. un  numero da 1 a 100:
class Consumatore extends Thread {
    int id;
    Consumatore(int i) {
        System.out.println("Cons. n° "+ (i+1) + "creato");
        id = i+1;
    }
    public void run() {
        System.out.println("Cons. n° "+id+"partito...");
        //Fai qualcosa ....
    }
}
public class NThread {
    public static void main(String[] args) {
        int n=(int)(Math.random()*100);
        for (int i=0;i<n;i++)
        new Consumatore(i).start();
    }
}
Non lo ho provato ma dovrebbe funzionare ... di solito se hai dei
consumatori vuol dire che hai anche dei produttori e un buffer, il
riferimento ai thread lo mantieni attraverso dei metodi nella classe buffer,
es:
class Buffer {
Consumatore c;
void registra(Consumatore x) {
    c=x;
}
}
chiamato al momento della costruzione del Thread...
class Consumatore ....
    int id;
    Buffer b;
    Consumatore(int i, Buffer b) {
        id = i;
        this.b = b;
        b.registra(this);
    }
    ...
}
Più o meno dovrebbe andare bene, fai qualche prova ...
Ciao, Grava

Grava wrote:

Ora come ora non ho il tempo di spiegare bene la cose,
cmq tenete conto che è NECESSARIO che alcuni metodi siano synchronized
(quelli di accesso al buffer condiviso)
Leggete la doc. di java e cercate su google con keyword tipo programmazione 
concorrente, producer-consumer
l'errore a run time è sicuramente dovuto a problemi di sincronizzazione tra 
i thread perche' non usi metodi e/o oggetti synchronized
M.

th.start();
Mentre sarebbe dovuto essere cosě:
for(int i=0; i<n; i++)
{
  consumatore th=new consumatore();
  th.start();
}
(tenete conto che in questo modo perder i riferimenti ai vari consumatori
creati ma questa č solo una soluzione.. avrebbe potuto usare un vettore di
oggetti consumatore etc etc)
Ciao ciao
Dani
--
Daniele Piras
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If at first the idea is not absurd then there is no hope for it. - Albert
Einstein
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 
Hai ragione, avevo letto male il post iniziale di RISC! :-P
 
Mi sorge un dubbio sul tuo codice qui sopra:
i thread creati perdono il riferimento ad essi stessi, quindi in teoria 
dovrebbero essere eliminati dal garbage collector....
Questo vale anche per i thread ? O solo per gli oggetti ordinari ?
Forse un modo per veridicarlo è fare l'override di finalize()...

 Forse un modo per veridicarlo è fare l'override di finalize()...
No .. non è così .. il Garbage collector non eliminerà quei thread.
Questo è dovuto al fatto che il meccanismo del Garbage Collector funziona in
modo tale che elimina un oggetto quando non riesce a ritrovare un "percorso"
dalla root seguendo tutti gli oggetti nidificati (il meccanismo è molto più
complesso perchè esistono diversi tipi di riferimenti forti, deboli,fantasma
etc ..) e i Thread vengono considerati diciamo (mi scusino il termine i guru
del Newsgroup) "oggetti di root" quindi non verranno eliminati.
Tanto è vero che se in una applicazione vi è un thread attivo anche se
questa è arrivata alla conclusione del main la tua applicazione non
terminerà (perchè il thread la terrebbe attiva) a meno che non si utilizzi
il metodo setDaemon( true ) (ed in questo caso il thread viene terminato
quando l'applicazione termina)
Spero di non averti confuso ancora di più le idee e di essermi almeno un
pochino spiegato ..



Scusate, io non ho avuto il tempo di provarlo, ma siamo sicuri che funziona
facendo "n" new sullo stesso refernce "th" di consumatore?
Grava

 ha scritto nel messaggio
news:tyVs8.2726$vF6....@news2.tin.it...


 facendo "n" new sullo stesso refernce "th" di consumatore?
Si certo funziona ... non funzionerebbe se invocassi "n" volte il metodo
"start" di *uno stesso* oggetto consumatore (come era all'inizio) ma in
questo caso "th" viene riallocato per ogni iterazione del ciclo .. questo
vuol dire che abbiamo un nuovo consumatore per ogni iterazione.


 Dani
L'accenno al meccanismo di gc era molto chiaro. Ora ho capito un po' meglio!
Grazie.
Ciao
Marcello