Newsgroup: it.comp.lang.delphi
Titolo: Thread multipli

Ciao a tutti.
Sapete se è possibile, e come, avviare più istanze dello stesso thread
contemporaneamente?
Ad esempio, dall'Execute di un MyTThread = class(TThread) chiamo una
procedura che fa un determinato calcolo su numeri random.
Se avvio più sessioni dello stesso eseguibile ottengo delle elaborazioni
parallele.
Si può ottenere il medesimo risultato da un solo eseguibile avviando lo
stesso thread più volte ma potendo sospendere o fermare  ognuno di essi
individualmente?
V.

contemporaneamente?
Probabilmente vuoi dire "più istanze della stessa classe derivata da
TThread".  Il "thread" in sé, difatti, è l'elaborazione specifica.
E' possibile.  Scrivo al volo (non compilato):
var
  MyThreadArray: array [0..99] of TThread;
...
// creo i thread 
for I := Low(MyThreadArray) to High(MyThreadArray) do
  MyThreadArray[I] := TMyThread.Create(False);

Create(Suspended : Boolean);
Il parametro Suspended da passare al metodo, permette di definire il
comportamento del thread in seguito alla sua creazione. 
Impostando questo parametro a False (valore predefinito) il thread viene
attivato immediatamente dopo essere stato creato. Se il parametro
Suspended ha valore true, il thread viene creato e immediatamente sospeso,
ovvero la sua esecuzione non ha inizio fino ad una chiamata al metodo
Resume della classe TThread. Per sospendere di nuovo il thread dopo il suo
avvio, è disponibile il metodo Suspend. Esistono altri metodi che
permettono di controllare l'esecuzione del thread come Terminate che
decreta l'arresto definitivo del thread.
Priority permette di impostare la priorità di esecuzione del thread su 7
livelli differenti di priorità da un minimo di tpIdle ad un massimo di
tpTimeCritical; FreeOnTerminate che permette di specificare se l'oggetto
thread creato deve essere distrutto al termine dell'esecuzione del codice
del thread.
Piu' in dettaglio per Execute:
Type NomeClasse = class(TThread)
private
{ Private declarations }
protected
{ Public declarations }
Procedure Execute; override;
end;
Implementation
Procedure NomeClasse.Execute;
Begin
//Inserire qui il codice da eseguire nel thread
End;
Da notare che il codice del metodo Execute, viene eseguito una volta sola
quindi raggiunta l'ultima istruzione del metodo Execute, l'esecuzione del
thread si arresta. Per eseguire più volte lo stesso codice all'interno del
thread, occorre ricorrere ad un ciclo e, cosa importante, ad ogni
esecuzione del ciclo controllare il valore della proprietà Terminated del
thread per interrompere il ciclo quando l'esecuzione del thread viene
interrotta. Una tipica implementazione del metodo Execute è la seguente
Procedure NomeClasse.Execute;
Begin
While not Terminated do
Begin
//Inserire qui il codice da eseguire nel thread
End;
End;
Una importante considerazione da fare riguardo al metodo Execute, sta nel
fatto che non si può eseguire codice che fa riferimento ad oggetti della
VCL. Questo perchè gli oggetti della VCL vengono eseguiti in un thread
differente da quello in esecuzione all'interno del metodo Execute e quindi
si potrebbero avere problemi di accesso alle loro proprietà ed ai lor
metodi. Per evitare ciò, la classe TThread mette a disposizione il metodo
Synchronize che permette appunto di sincronizzare i due threads in maniera
tale da paermettere l'accesso sicuro alle proprietà ed ai metodi
dell'oggetto voluto. Esistono anche oggetti della VCL chiamati Thread-Safe
che sono stati realizzazti appositamente per l'utilizzo in ambienti
multithread e che permettono di gestire gli accessi al loro contenuto in
maniera concorrente. Un esempio di questi oggetti è la ThreadList.
Al termine dell'esecuzione del codice thread, è possibile eseguire del
codice di pulizia scrivendo un gestore di evento per l'unico evento che
mette a disposizione la classe TThread, l'evento OnTerminate.
La classe TThread permette anche di sincronizzare l'esecuzione del suo
thread con altri thread. tramite il metodo WaitFor della classe TThread è
possibile attendere il termine dell'esecuzione di un'altro thread. Questo
metodo non restituisce il controllo finchè l'altro thread non è terminato.
Potrebbe capitare la necessità di intercettare quando un thread ha
terminato una certa operazione piuttosto che attendere che l'intero thread
completi la sua esecuzione. In questo caso esistono gli oggetti evento
(TEvent). Quando un thread deve comunicare ad altri di aver completato la
un certa operazione, chiama il metodo SetEvent dell oggetto evento. Per
disattivare la segnalazione dell'evento è sufficiente effettuare una
chiamata al metodo ResetEvent dell'evento. Gli oggetti evento devono
essere creati in un campo d'azione globale per far si che tutti i thread
interessati possano accedervi. Il thread che necessita di attendere il
completamento di una determinata operazione, crea ed avvia i thread
interessati ed effettua una chiamata la metodo WaitFor dell'oggetto evento
indicando un intervallo di tempo da attendere per la ricezione del
segnale. Il tempo da attendere per il settaggio del segnale è espresso in
millisecondi e può essere impostato anche su INFINITE. Al ritorno dalla
sua chiamata, il metodo WaitFor restituisce uno dei seguenti valori:
wrSignaled, wrTimeout, wrAbandoned, wrError.
L'oggetto evento, o meglio la classe TEvent, non è altro che una struttura
wrapper per gli oggetti event di Windows.
Altre strutture permettono di semplificare la gestione di multithread. Per
esempio, quando gli oggetti su cui si sta operando non possiedono metodi o
proprietà specifiche per operare in ambineti multithread, si può ricorrere
alle sezioni critiche. Le sezioni critiche permettono di far accedere ai
metodi o alle proprietà di un determinato oggetto un solo thread alla
volta, onde evitare conflitti di accesso. Questa struttura è definita
nella classe TCriticalSection che possiede due metodi: Acquire, Release.
Quando un thread deve accedere alla sezione critica, deve prima chiamare
il metodo Acquire per bloccare l'accesso agli altri threads e rilasciare
tale blocco tramite il metodo Release al termine dell'operazione.
--- posted by geoForum on 
http://www.delphiedintorni.it

   MyThreadArray[I] := TMyThread.Create(False);
Si, č quello che mi occorre...!
Se si puň trattare come un'array potrebbe accettare anche un SetLength cosě
da limitare l'uso della memoria al numero di istanze decise a runtime...
comunque ora provo
Grazie
V.

da limitare l'uso della memoria al numero di istanze decise a runtime...
Certo, e in quel caso sarebbe un:
var
  MyThreadArray: array of TThread;
Valuta, nel caso, se usare una TObjectList o un qualsiasi altro
container.

 wrote:
<snip>
Bastava un link all'URL da cui hai copiato:
http://programmazione.html.it/guide/lezione/1231/sviluppo-di-applicazioni-multithread/
Sparisci, troll.

Copiavo dal HD in rete, non so se potevi linkarti....
Come hai fatto a farti Trollare in questo modo... Sei quello che ci e'
cascato di piu' ?


 Create(Suspended : Boolean);
[...]
Non era la risposta alla mia domanda
V

 più volte ma potendo sospendere o fermare ognuno di essi individualmente?
Il parametro Suspended da passare al metodo, permette di definire il
comportamento del thread in seguito alla sua creazione. Impostando questo
parametro a False (valore predefinito) il thread viene attivato
immediatamente dopo essere stato creato. Se il parametro Suspended ha
valore true, il thread viene creato e immediatamente sospeso, ovvero la
sua esecuzione non ha inizio fino ad una chiamata al metodo Resume della
classe TThread. Per sospendere di nuovo il thread dopo il suo avvio, è
disponibile il metodo Suspend. Esistono altri metodi che permettono di
controllare l'esecuzione del thread come Terminate che decreta l'arresto
definitivo del thread.
--- posted by geoForum on 
http://www.delphiedintorni.it

 Dhai leggi bene....
Rileggi bene tu...non ho chiesto come si gestisce un TThread
V.

fidati, 
Multitasking con prelazione non senza !


Multitasking con prelazione non senza !
Sě, sě, certo.

Si puň ottenere il medesimo risultato da un solo eseguibile avviando lo
stesso thread piů volte 
ma potendo sospendere o fermare ognuno di essi individualmente?
OGNUNO DI ESSI !!!!
Dai cazzo non facciamo i bambini !


stesso thread piů volte 
No.

Valter scrive:
"Si puň ottenere il medesimo risultato da un solo eseguibile avviando lo
stesso thread piů volte 
ma potendo sospendere o fermare ognuno di essi individualmente?
"
1) Suspended=true 
Il thread viene creato e immediatamente sospeso, ovvero la sua esecuzione
non ha inizio fino ad una chiamata al metodo Resume della classe TThread
2) Suspended=false
il thread viene attivato immediatamente dopo essere stato creato. 
3) Terminate che decreta l'arresto definitivo del thread.


Si !
Rileggi il POST che ti ho mandato !!!!!


Devi avviare i Thread in CASCATA !!!!!
Li devi mettere tutti in stand by con suspande e lanciarli uno alla volta
dallo stesso eseguibile ! 
L'ho fatto io se vuoi ti posto il codice !


Devi avviare i Thread in CASCATA !!!!! 
Li devi mettere tutti in stand by con suspande e lanciarli uno alla volta
dallo stesso eseguibile ! 
Va in multitasking con prelazione !
Dhai cavolo ci sto lavorando sopra da una settimana !


Mi spiego meglio:
1) crea l'array dei Thread
2) Mettili in Suspended=true 
3) sgancia ogni Thread con un ciclo for mettendo Resume
e li lanci uno dopo l'altro con un intervallo di almeno 1/2 secondo...per
sicurezza.
Fidati ! So che non mi credi ma e' cosi'....
Ciao !


Si !
Rileggi il mio codice, troll.

Riletto, mi sembra che vada bene !
Lanciali in cascata o si blocca tutto ... 
Magari mezzo secondo e' troppo se usi dal P3 in su bastano 200 millisecondi.
Ciao !


 dallo stesso eseguibile ! 
Minchiata.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

si, certo...


