Newsgroup: it.comp.lang.delphi
Titolo: Verificare se un TThread è stato creato

Ciao a tutti.
Come si può verificare da codice se un thread è stato creato?
In pratica ho due thread, uno creato all'avvio dell'applicazione l'altro a
scelta dell'utente.
Il primo thread, il principale, può essere sospeso e riavviato sempre
dall'utente ma devo contemporaneamente sospendere e riavviare anche il
secondo thread congiuntamente al primo sempre che sia stato in precedenza
creato.
Naturalmente ogni tentativo di accesso alle proprietà del secondo thread
restituiscono AV se non è stato creato.
Anche tentare di stabilire se al thread è stato assegnato un ID non va a
buon fine.
C'è un modo per verificare la cosa?
Grazie
Valter

 Come si pur verificare da codice se un thread h stato creato?
Assigned() ?
-- 
Vuoi distribuire il tuo sito web su CD/DVD?
Prova 
http://www.dwebpro.com/
Vuoi diventare un esperto programmatore Delphi?
Vieni a fare uno stage con noi: 
http://www.creativepark.it/stage/


Assigned() !
Questa poi...forse dovrei staccare la spina per qlche gg anzichč lavorare
anche il 25 aprile
:-)
Grazie
V

 Questa poi...forse dovrei staccare la spina per qlche gg anzichè lavorare


 NomeThread:=Nil;
Non risolve il problema e in generale non serve a molto.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it


Scusa  Andrea,
ma a quale problema fai riferimento?
Mi "parrebbe" che il codice giri benino senza lasciare strascichi 
apparenti...
La mia domanda era proprio da...stanchezza...ed effettivamente con 
Assigned() ho risolto ma pensi che sia necessario approfondire i controlli 
tra una terminazione ed un riavvio di un thread?
Grazie
Valter

 ma a quale problema fai riferimento?
A parte il fatto che se ti funziona bene, lascialo così e la soluzione va
bene per il tuo caso ;-)
Dal mio punto di vista, controllare l'assigned di un'istanza di classe
tthread *non necessariamente* indica che il codice dell'execute sia stato
eseguito. Personalmente parlando preferisco tenermi le istanze dei thread e
ispezionare invece una proprietà booleana quale ad esempio
"TerminatoConSuccesso". Questo favorisce l'incapsulamento ma soprattuto ti
svincola dall'assegnare a nil un'istanza, operazione la quale non dovrebbe
mai essere utilizzata come flag indicatore di un flusso di processo.
Mi spiego diversamente: se devo farti sapere se il mio flusso di processo è
stato eseguito tutto con successo, ti espongo una proprietà e lascio che
sia lei comunicare all'esterno l'esito. Tu, se vuoi usare la mia classe
tthread, la istanzi, la mandi in esecuzione, poi vai a testare la mia
proprietà anzichè l'assigned dell'istanza di classe! ;-)
Ciao
-- 
Morde

 tra una terminazione ed un riavvio di un thread?
Non capisco che vuoi dire.


 sia lei comunicare all'esterno l'esito.
Il flusso di un processo deve essere mantenuto esternamente ai thread; il
thread deve comunicare con l'esterno ogni fase della sua elaborazione e
sarà l'"esterno" a sapere se ha compiuto o meno correttamente tutte le sue
fasi.


 eseguito.
Si, ho capito quello che intendi...nel mio caso però il thread viene creato
ed
attivato a seguito di un solo input e fermato e terminato nello stesso
modo.
Dunque credo che Assigned() dovrebbe darmi sufficienti garanzie per
stabilire se tale thread è ad un dato momento esistente o meno.
Grazie
Ciao
Valter

 Non capisco che vuoi dire.
E' a causa del malinteso...
io ho letto la risposta di Giorgio come un suggerimento *addizionale*
sull'uso dei thread tu presumibilmente come una risposta alla mia domanda.
Dunque ho pensato che il problema al quale facevi riferimento potesse
riguardare le attività del thread citato nel mio post di apertura e ti
chiedevo se avevi suggerimenti in proposito.
Tutto qui...
Ciao
Valter

 stabilire se tale thread è ad un dato momento esistente o meno.
Seguendo la tua logica di processo, si, sono d'accordo con te.
ciao
-- 
Morde

> Seguendo la tua logica di processo, si, sono d'accordo con te.
Morde, talvolta, anche in questo modo, possono verificarsi dei problemi. 
Dipende da come è stato strutturato il thread e da come comunica ai 
thread da cui dipende, o al main thread, la sua effettiva terminazione.
Se, ad esempio, il thread si autodistrugge, poco prima della distruzione 
in genere invia un postmessage (oppure meccanismi di comunicazione 
alternativi da usare) per segnalare la sua imminente distruzione. 
Intanto il flusso del main thread continua e non ci sono garanzie che 
l'elaborazione della coda dei messaggi in cui abbiamo la segnalazione 
della distruzione del thread venga eseguita a tale velocità da impedire 
di arrivare all'istruzione Assigned().
In questo caso il thread pur essendosi autodistrutto verrà visto ancora 
come "vivo" dall'Assigned ed il codice tenterà di accedervi generando un AV.

 come "vivo" dall'Assigned ed il codice tenterà di accedervi generando un AV.
Infatti. Tant'è che nella soluzione da me generalmente adottata pubblico
questa informazione in una property a sola lettura in modo che possa essere
ispezionata senza problemi ed in ogni momento.
-- 
Morde

ispezionata senza problemi ed in ogni momento.
Per una programmazione sicura bisognerebbe adottare un modello ad
eventi. Al thread deve bastare comunicare all'esterno di aver compiuto
tutte le sue operazioni.

 eventi.
Interessante: alludi agli eventi implementati in delphi? O a qualcosa di
più generico?
-- 
Morde