Newsgroup: it.comp.lang.delphi
Titolo: 2 Favori grazie a tutti

Ciao vi sarei grato se mi aiutaste a risolvere 2 problemini:
1 - Applicazione che accede anche in remoto ad un SQL server,
    ho costruito un thread che fa dei ping e a seconda del tempo di
risposta
    reimposta i timeout delle tabelle che ricevono i dati da SQL server,
per di
    più, attraverso questo thread faccio il refresh di alcune tabelle
più
    grosse ed eccoci al punto : come faccio a sapere se la tabella di
cui devo
    fare il refresh è attiva (non aperta) se c'è qualche componente
data-aware
    attivo attaccato mediante il datasource alla tabella...un array del
tipo:
    Table.Controls dove dentro trovare [dbgrid1, dbedit2, ecc...].
2 - Dove posso trovare un po' di documentazione, magari in italiano sui
thread
    oltre ai demos di delphi (quelli li ho già guardati e qualcosa sono
già
    riuscito a combinare)
Grazie in anticipo e CIAO :-)))))))) 
-- 
Posted from  [213.82.192.70] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

     riuscito a combinare)
Non saprei dove indirizzarti per la documentazione, pero' sto giusto
lavorando con i thread in questo periodo e ci ho fatto un pochina di
esperienza.. se ti serve qualcosa in particolare chiedi pure..
Ciao !

in particolare non ho ben capito la Synchronize a cosa serve?
nominalmente per sincronizzarsi con la vcl e un po' a tastoni la ho
utilizzata,
ma una spiegazione più chiara mi farebbe piacere.
Tante grazie ancora anche perchè sui libri come "Programmare con
Delphi5" di Marco non
ho trovato niente.


 ma una spiegazione più chiara mi farebbe piacere.
Praticamente, quando tu crei un thread, il codice che metti nel metodo
Execute, viene eseguito contemporaneamente con il thread principale.
Ovviamente come in tutte le esecuzioni parellele, potrebbero accadere dei
conflitti, cioe' manipolazioni contemporanee di variabili ecc ecc che
potrebbero far perdere dati. Anche la manipolazione dei componenti della
form potrebbe portare ad errori. Ad esempio se dall'execute chiami:
memo1.lines.add(s);
e il thread principale sta modificando il campo text del memo1, potresti
incorrere in conflitti.
Per evitare cio' generalmente si dovrebbero usare gli oggetti di
sincronizzazione che mette a disposizione Windows, cioe' semafori, eventi,
criticalsections, mutex ecc, il cui uso pero' non e' banale. Per i casi
semplici invece, TThread permette di chiamare una procedura dall'Execute in
modo che sia eseguita nel thread principale.
Quello che fa in pratica e': interrompere il thread che hai creato, far
eseguire il metodo dal thread principale, e poi far riprendere il thread
secondario.
Il classico esempio in cui cio' torna utile e' un thread secondario che
compie un conto molto lungo, che di tanto in tanto aggiorna una ProgressBar
sulla form principale.
Procedure TMioThread.AggiornaBarra;
begin
 ProgressBar1.position:=MioThread.Valore;
end;
procedure TMioThread.Execute(...);
begin
// fa i suoi conti
// il metodo AggiornaBarra viene chiamato sul Thread Principale
// mentre questo thread viene momentaneamente sospeso.
Synchronize(AggiornaBarra);
// fa altri conti
end;
Per capire se un metodo e' thread-safe (cioe' non puo' creare criticita') di
solito basta vedere che qusto metodo non scriva nessun dato. Se e' un metodo
che legge solo dati, generalmente si puo' stare sicuri.. Attento che i bug
causati dalle criticita' sono tra i piu' impestati, perche' non sono
"deterministici", con lo stesso codice a volte possono capitare e a volte
no..
Spero di essermi spiegato bene :D
Ciao !                                                   {MSX}

David,
per la documentazione (in inglese) prova questo link:
http://www.pergolesi.demon.co.uk/prog/threads/ToC.html
E' veramente buona.
Ciao
guastatore

 ma una spiegazione più chiara mi farebbe piacere.
La VCL è single-thread nella quasi totalità (fa eccezione TCanvas, lo
streaming property, TThreadList). Questo vuol dire che permette di accedere
ai suoi elementi solamente attraverso il thread primario.
Come sai il metodo Synchronize ti permette di eseguire una procedura che può
accedere agli oggetti VCL del thread primario.
Questo il codice sorgente di Synchronize:
procedure TThread.Synchronize(Method: TThreadMethod);
begin
  FSynchronizeException := nil;
  FMethod := Method;
  SendMessage(ThreadWindow, CM_EXECPROC, 0, Longint(Self));
  if Assigned(FSynchronizeException) then raise FSynchronizeException;
end;
In questa procedura viene memorizzato nel campo privato FMethod la procedura
da eseguire e viene inviato alla window procedure dello stesso thread un
messaggio CM_EXECPROC passando inoltre come lparam il parametro Self (cioè
lo stesso thread). Dato che la window procedure è stata creata dal thread
primario anche il metodo passato viene eseguito nel thread primario.
E' un procedimento un pò intrecciato. Spero di essere stato chiaro.
ciao
guastatore

 sui thread
Sul borland community c'e' l'articolo Article ID: 22411 dal titolo
"Delphi threading by example"; poi ci sono un paio di articoli che mi
paiono piuttosto completi su
http://www.sklobovsky.com/community/threadmare/threadmare.htm
e li' vicino.

VI RINGRAZIO ADESSO STUDIO E VI FACCIO SAPERE ;-)))
CIAO CIAO
-- 
Posted from 
sita.adsl.fol.it
 [213.26.241.44] 
