Newsgroup: it.comp.lang.delphi
Titolo: TThread con chiamate a due Function

 Buongiorno, vi potrą sembrare una domanda banale, ma necessito di una 
risposta sicura, quindi le prove che ho fatto non mi sono bastate per 
avere una conferma:
Se ho 2 TThread che richiamano la funzione:
//..............................................
function PIPPO(var i: integer; testo : string);
  begin
    Memo1.Lines.Add(inttostr(i) + ')' + testo);
  end;
//..............................................
e i due TThread quasi perfettamente uguali (cambia il nome TTestThread e 
il tempo di SLEEP):
//..............................................
procedure TTestThread.Execute;
var i : integer;
begin
  while (true) do
    begin
      if (Terminated) then break;
      PIPPO(i,'test');
      sleep(2000);
    end;  //end WHILE
end;
//..............................................
se questi 2 TThread sono attivi contemporaneamente ma il tempo di SLEEP č 
diverso, quando uno dei due sta processando la funzione PIPPO() e l'altro 
richiama anch'esso la funzione, succede un putiferio?
"Puriferio" nel senso che mi potrei trovare (anche se sembra funzionare a 
random) nella MEMO1 questa situazione:
//########### GIUSTO #############
1) test //del primo thread
2) test //del primo thread
1) test //del secondo thread
3) test //del primo thread
2) test //del secondo thread
// in questo caso ogni TThread utilizza le sue variabili passate alla 
funzione sotto forma di VAR
//########### SBAGLIATO #############
1) test 
2) test
3) test
4) test
5) test
//in questo caso pur essendo due TThread alla fin fine il VAR nella 
funzione PIPPO si incrementa ogni volta, invece di incrementare a seconda 
del TThread
--- posted by geoForum on 
http://www.delphiedintorni.it

Usa il metodo Synchronize per chiamare la tua funzione dalla procedura 
Execute (l'help spiega molto bene il funzionamento)
Ciao,
David

end;
--- posted by geoForum on 
http://www.delphiedintorni.it

 il tempo di SLEEP):
Che ci sia un tempo di sleep non cambia nulla.  
I thread rimangono due cloni, che potrebbero comunque "collidere" sulla
stessa risorsa in qualsiasi momento.  Questo in generale, nel tuo caso (a
meno di capire dove inizalizzi i e dove lo incrementi) l'ordine con cui
vengono scritti i valori è assolutamente casuale.  L'incremento è limitato
al contesto del singolo thread e NON è relativo ai due thread.  Se hai
bisogno di un contatore comune devi gestire un unico counter e
sincronizzare l'accesso per l'incremento.  Quanto all'uso di Synchronize,
nel tuo caso non è strettamente necessario, serve solo se hai bisogno di
gestire corse critiche.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 gestire corse critiche.
Mi correggo: fai uso di un Memo1, che sicuramente appartiene a una form.
Devi usare Synchronize.


 Puoi usare il Metodo Synchronize 
E' _obbligatorio_ usare il metodo Synchronize quando condividi l'accesso a
oggetti VCL.  Synchronize utilizza, internamente, una critical section,
che è _molto_ più veloce di un mutex (non essendo un oggetto kernel).


Puoi usare il Metodo Synchronize ma sappi che allora la funzione inserita
sara' sempre eseguita dal Thread principale dell'applicazione, perdendo
ovviamente in velocita'.
Un'altra soluzione che fornisce migliori prestazioni e' l'uso dei Mutex, li
trovi nell'help di win32 o in Internet con esempi vari, compresi i siti
Torry, DSP, delphipage..
Con entrambe le soluzioni potresti togliere gli Sleep a meno che non trovi
un rallentamento dell'applicazione principale.
Ciao Giorgio Padoan

Pardon non avevo fatto caso al contenuto della funzione: usa un componente 
VCL per cui Andrea ha perfettamente ragione.
Giorgio
"Andrea Laforgia" <x...@xx.xx> ha scritto nel messaggio 
news:d8road$daj$1...@news.newsland.it...
