multithreading - Indy 10 IdTCPClient Reading Data usando un hilo separado?

delphi sockets

Question

Pregunta: Lo que estoy buscando es la forma más típica o de mejores prácticas de usar un hilo separado para recibir datos usando un IdTCPClient en Indy 10.

Antecedentes: el siguiente código es una muestra de lo que trato de hacer con las piezas de procesamiento de datos reales eliminadas para mayor claridad. La idea del subproceso es recibir todos los datos (tamaño variable con un encabezado que declara el resto de la longitud del mensaje) y luego analizarlos (eso es lo que hace el procedimiento HandleData) y activar un manejador de eventos según el comando.

TIdIOHandlerSocket se pasa al hilo por la aplicación principal, que también escribe datos en el zócalo cuando sea necesario.

TScktReceiveThread = class(TThread)
  private
    { Private declarations }
    procedure HandleData;
  protected
    procedure Execute; override;
  public
    FSocket: TIdIOHandlerSocket;
    constructor Create(CreateSuspended: boolean);
  end;


procedure TScktReceiveThread.Execute;
var
  FixedHeader: TBytes;
begin
  Assert(FSocket <> nil, ''You must assign the connected socket to the receiving thread'');
  SetLength(FixedHeader, 2);
   while not Terminated do
    begin
      if not FSocket.Connected then
        Suspend
      else
        begin
          FSocket.CheckForDataOnSource(10);
          if not FSocket.InputBufferIsEmpty then
           begin
            FSocket.ReadBytes(FixedHeader, SizeOf(FixedHeader), false);
            // Removed the rest of the reading and parsing code for clarity
            Synchronize(HandleData);
           end;
        end;
    end;
end;

Como prefijo, he utilizado otra pregunta de StackOverflow que trata sobre los componentes de servidor de Indy: " Delphi 2009, Indy 10, TIdTCPServer.OnExecute, cómo capturar todos los bytes en InputBuffer " para obtener la base de lo que tengo hasta ahora .

¡Gracias por cualquier ayuda!

Answer 1

Estás en el camino correcto. Indy está destinado a ser usado así. Utiliza sockets de bloqueo , por lo que la llamada a ReadBytes no se devuelve hasta que no se lee lo que ha pedido. Contraste eso con los zócalos sin bloqueo, donde una llamada puede regresar temprano, por lo que puede sondear o recibir notificaciones de forma asíncrona para determinar cuándo se ha completado una solicitud.

Indy está diseñado con la expectativa de que los objetos del socket tengan sus propios hilos (o fibras). Indy viene con TIdAntifreeze para las personas que quieren arrastrar y soltar componentes de socket en sus formularios y módulos de datos y usar los componentes de Indy del hilo principal de la GUI, pero generalmente no es una buena idea si puedes evitarlo.

Como su hilo no puede funcionar sin FSocket asignado, le aconsejo que simplemente reciba ese valor en el constructor de la clase. Afirma en el constructor si no está asignado. Además, crear un hilo no suspendido es un error , entonces ¿por qué incluso dar la opción? (Si el hilo no se crea suspendido, entonces comenzará a ejecutarse, verificará si FSocket está asignado y fallará porque el hilo de creación no ha llegado a asignar ese campo todavía).

Answer 2

Si desea evitar la sobrecarga impuesta creando clases de subprocesos para cada intercambio de datos cliente-servidor, puede crear una clase de subprocesamiento móvil como se describe en

http://delphidicas.blogspot.com/2008/08/anonymous-methods-when-should-they-be.html

Tuve el mismo problema hace unos días y me acaba de escribir una clase TMotileThreading que tiene funciones estáticas que me permiten crear subprocesos utilizando la nueva función de método anónimo de D2009. Se ve algo como esto:

type
  TExecuteFunc = reference to procedure;

  TMotileThreading = class
  public
    class procedure Execute (Func : TExecuteFunc);
    class procedure ExecuteThenCall (Func : TExecuteFunc; ThenFunc : TExecuteFunc);
  end;

El segundo procedimiento me permite realizar una comunicación cliente-servidor como en su caso y hacer algunas cosas cada vez que los datos han llegado. Lo bueno de los métodos anónimos es que puede usar las variables locales del contexto de llamada. Entonces una comunicación se ve así:

var
  NewData  : String;
begin
  TMotileThreading.ExecuteThenCall (
    procedure
    begin
      NewData := IdTCPClient.IOHandler.Readln;
    end,
    procedure
    begin
      GUIUpdate (NewData);
    end);
 end;

El método Execute y ExecuteThenCall simplemente crea un hilo de trabajo, configura FreeOnTerminate en verdadero para simplificar la gestión de la memoria y ejecutar las funciones proporcionadas en los procedimientos de Ejecución y Terminación del subproceso de trabajo.

Espero que ayude.

EDITAR (como solicitó la implementación completa de la clase TMotileThreading)

type
  TExecuteFunc = reference to procedure;

  TMotileThreading = class
  protected
    constructor Create;
  public
    class procedure Execute (Func : TExecuteFunc);
    class procedure ExecuteAndCall (Func : TExecuteFunc; OnTerminateFunc : TExecuteFunc;
                                SyncTerminateFunc : Boolean = False);
  end;

  TMotile = class (TThread)
  private
    ExecFunc             : TExecuteFunc;
    TerminateHandler     : TExecuteFunc;
    SyncTerminateHandler : Boolean;
  public
    constructor Create (Func : TExecuteFunc); overload;
    constructor Create (Func : TExecuteFunc; OnTerminateFunc : TExecuteFunc;
                        SyncTerminateFunc : Boolean); overload;
    procedure OnTerminateHandler (Sender : TObject);
    procedure Execute; override;
  end;

implementation

constructor TMotileThreading.Create;
begin
  Assert (False, ''Class TMotileThreading shouldn''''t be used as an instance'');
end;

class procedure TMotileThreading.Execute (Func : TExecuteFunc);
begin
  TMotile.Create (Func);
end;

class procedure TMotileThreading.ExecuteAndCall (Func : TExecuteFunc;
                                                 OnTerminateFunc : TExecuteFunc;
                                                 SyncTerminateFunc : Boolean = False);
begin
  TMotile.Create (Func, OnTerminateFunc, SyncTerminateFunc);
end;

constructor TMotile.Create (Func : TExecuteFunc);
begin
  inherited Create (True);
  ExecFunc := Func;
  TerminateHandler := nil;
  FreeOnTerminate := True;
  Resume;
end;

constructor TMotile.Create (Func : TExecuteFunc; OnTerminateFunc : TExecuteFunc;
                            SyncTerminateFunc : Boolean);
begin
  inherited Create (True);
  ExecFunc := Func;
  TerminateHandler := OnTerminateFunc;
  SyncTerminateHandler := SyncTerminateFunc;
  OnTerminate := OnTerminateHandler;
  FreeOnTerminate := True;
  Resume;
end;

procedure TMotile.Execute;
begin
  ExecFunc;
end;

procedure TMotile.OnTerminateHandler (Sender : TObject);
begin
  if Assigned (TerminateHandler) then
    if SyncTerminateHandler then
      Synchronize (procedure
                   begin
                     TerminateHandler;
                   end)
    else
      TerminateHandler;
end;