Problemas con Threads

[[gluglu]]

En el proceso de cálculo de cada instancia de TList_General, cuando ya termino de mostrar los datos en un DBGrid, entonces creo y lanzo el Thread :

Código Delphi [-]
procedure TList_General.Initialize;
begin
 
  ....
  LabelTime.Caption := 'Consultada generada a las ' + FormatDateTime('hh:nn:ss', Time);

  Calculate_Total := TCalculate_Total.Create(True);
  Calculate_Total.FreeOnTerminate := True;
  ... paso unas variables a Calculate_Total ...
  Calculate_Total.Resume;
 
end;

En sí mismo Calculate_Total se ejecuta :

Código Delphi [-]
procedure TCalculate_Total.Execute;
begin
 
  // Realizo operaciones con la BBDD y Tablas, por lo que genero un 
  // acceso totalmente independiente en el propio Thread
 
  CTDatabase := TIBDatabase.Create(nil);
  CTDataBase.DatabaseName := DM0.IBDatabase1.DatabaseName;
  CTDataBase.LoginPrompt  := DM0.IBDatabase1.LoginPrompt;
  CTDataBase.Params       := DM0.IBDatabase1.Params;
  CTDataBase.SQLDialect   := 3;
  CTDataBase.Connected    := True;
 
  CTTransaction := TIBTransaction.Create(nil);
  CTTransaction.DefaultDataBase := CTDatabase;
  CTTransaction.StartTransaction;
 
  CTDataSet1 := TIBDataSet.Create(nil);
  CTDataSet1.Transaction := CTTransaction;
 
  ....
 
  // Realizo varios Cálculos y sincronizo de esta forma
 
  Update_Var := 1;
  Synchronize(UpdateMainForm);
 
  CTDataSet4.First;
  while not CTDataSet4.Eof do begin
 
    if Terminated then Break;
 
    with CTDataSet2 do begin
      SelectSQL.Clear;
      ....
      Prepare;
      Open;
    end;
 
    ....
 
    if Terminated then Break;
 
    Update_Var := 2;
    Synchronize(UpdateMainForm);
 
    CTTransaction.CommitRetaining;
    CTDataSet4.Next;
 
  end;
 
  if not Terminated then begin
    Update_Var := 3;
    Synchronize(UpdateMainForm);
  end;
 
  CTTransaction.Active := False;
  CTDataBase.Close;
  CTDataBase.Free;
  CTTransaction.Free;
  CTDataSet1.Free;
 
end;

procedure TCalculate_Total.UpdateMainForm;
begin
  MainForm.Arr_List[Pos_Array].UpdateForm(Update_Var);
end;

procedure TList_General.UpdateForm(Update_Var: Integer);
begin
 
  if Update_Var = 1 then begin
    ...
  end;
 
  if Update_Var = 2 then begin
    ...
  end;
 
  if Update_Var = 3 then begin
    ...
  end;
 
  Application.ProcessMessages;
 
end;

Si cierro anticipadamente (antes de que termine el Thread de realizar sus cálculos) el Form List_General correspondiente :

Código Delphi [-]
procedure TList_General.FormClose(Sender: TObject; var Action: TCloseAction);
begin
 
  if PanelTimer.Visible then begin
    while not Calculate_Total.Terminated do begin
      Calculate_Total.Terminate;
    end;
    PanelTimer.Visible := False;
    Application.ProcessMessages;
  end;
 
  ...
 
  Action := caFree;
  MainForm.Arr_List[Pos_Array] := nil;
 
end;

No Termino el Thread Calculate_Total en ningún otro sitio de la aplicación.

Programando otros asuntos me dí cuenta de una cosa que me puse a pensar, y ello me llevó a comprobar esta parte del código correspondiente a mi formulario de listados. Ahí pude comprobar lo que indicaba anteriormente, si creo dos instancias de List_General, diferenciadas por su posición en MainForm.Arr_List[i], entonces al terminar el primero, también se para el segundo.

Según lo que indicas, Neftalí, entiendo como tu que no debería ser así.

A ver si el problema podría ser otro : En el Thread a su vez llamo a otro procedimiento que tienen que pasar un valor a una variable declarada como pública del Thread :

Código Delphi [-]
  TCalculate_Total =  class(TThread)
    procedure UpdateMainForm;
  private
    ....
  public
    Aux_Random      : Int64;
  protected
    procedure Execute; override;
  end;

Es el único problema que me puedo imaginar, si acaso. En el otro procedimiento al que se llama desde cada uno de los Threads que puedan estar activos concurrentemente, lo que hago es

Código Delphi [-]
Calculate_Total.Aux_Random := Aux_R1;

y ahí si me encontraría con el problema de no saber a qué instancia de Calculate_Total estaría pasnado el valor correspondiente.

Cómo se solucinaría esto ? Cómo haría referencia a la instancia del Thread Calculate_Total de un Form List_General en concreto cuya posición es una determinada en el Arr_List del MainForm ?

Se podría hacer esto ?

Código Delphi [-]
MainForm.Arr_List[i].Calculate_Total.Aux_Random := Aux_R1;

La verdad es que no lo he probado.

Pues lo dicho, es la única ocasión en la cual se podrían 'liar' las instancias concurrentes de Calculate_Total. De ningun otra forma.

Es por eso que pueda ser que al terminar una instancia termine también la otra ? De hecho es lo que ocurre.

Gracias de nuevo por vuestra ayuda.