Encapsulate Tclientsocket connections in Multithreads

Question

I have a variable number X of electronic equipment (Weather stations) in my local network, each equipment provides a Serversocket connection with an IP and a specific Port, I have an application developed in DELPHI XE5 that connects to all these equipment, my application knows what are the Ips and Ports of this equipment, because they are registered in the database, when opening my application, I dynamically create a connection [Tclientsocket (Array)] for each of these equipment, to which later I change a lot of information, like a conversation, I ask the temperature of all the equipment and they answer me, or I can ask the temperature for one of them, the humidity for another, the wind speed for another etc... through internal OPERATIONS.

Today I do a FOR loop of all the connected equipment and from this I know which operation with the equipment my software is and then I do the conversation randomly with each equipment, but this is slow, because as the number of equipment increases, Slows down the FOR. What I want to do is a Thread to eliminate FOR, I’d like to know if that’s possible. The events onConnect, Onread, etc... of my Tclientscojet are assigned in the creation of the Tclientsocket Array, so I end up having this wait of one to use, then the other and I cannot meet all the equipment at the same time.

I wish I could use Thread for this and meet all equipment at the same time, but I don’t know the concept and use.

[UPDATED]

Full source link, I did not post here because it passes a thousand lines:

https://mega.co.nz/#! bAVBwTAb! fdzyS9ENPMWul3wC8GFkKATiJ7whKB7Xzgo5FUHlD6M

Today I use this class I created extended from Tclientsocket:

type
  TTermoCenter = class(TClientSocket)
  private
    countSema: Thandle;
    access: TCriticalSection;
    ...
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure Push(inObject: TPalavra; priority: Integer); virtual;
    function Pop(pResObject: pObject; timeout: Integer): Boolean;
  end;

Here is the constructor:

constructor TTermoCenter.Create(AOwner: TComponent);
var
  I: Integer;
begin
  inherited;
  access := TCriticalSection.Create;
  ...
end;

Here is the destructor:

destructor TTermoCenter.Destroy;
var
  I: Integer;
begin
  ...
  access.Free;
  closeHandle(countSema);
  inherited;
end;

variable declaration:

var
  termocenters: array of TTermoCenter;

When creating my Form, I set the size of my Array

SetLength(termocenters, dm.sqlTermocenter.RecordCount);

And I create my connections based on what’s in the database: var Sockettmp: Ttermocenter;

  while not cds.Eof do
  begin
    SocketTmp := TTermoCenter.Create(nil);
    SocketTmp.name := 'cdsNome';
    SocketTmp.Port := 'cdsPorta';
    SocketTmp.ClientType := ctNonBlocking;
    SocketTmp.Host := 'cdsIP';
    // atribui eventos
    SocketTmp.OnRead := TCPRead;
    SocketTmp.OnConnect := TCPConnect;
    SocketTmp.OnDisconnect := TCPDisconnect;
    SocketTmp.OnError := TCPError;

    //Coloca no Array
    termocenters[I] := SocketTmp;
    try
      termocenters[I].Active := True;
      sleep(1000);
    except
      on E: Exception do
        frmMain.mmErros.Lines.Add(TimeToStr(now) + ' - ' + E.ClassName + ' CriaConexao : ' + E.Message);
        end;
      end;
    end;
  cds.Next;
end;
end;

This is a well summarized code of what I have today, I would like a help to implement Threads.

Answer 1

I will agree with @Pagenotfound that your question is very broad and awaiting a functional code.

I can give you a few steps to guide. Follow an example using Generics, Annonymous Methods and an anonymous Thread resource:

The idea is to have a connection pool and have a method that creates a Worker thread for each connection to perform a specific task

interface

uses
  System.Generics.Collections, Datasnap.Win.SConnect;

type
  TPoolConexoes = class(TObjectList<TSocketConnection>)
  private
    procedure SeuMetodoQueUsaConexao(const aConexao: TSocketConnection);
  public
    function NewConnection: TSocketConnection;
    function ObterConexoesPorStatus(const aStatus: string): TPoolConexoes;

    procedure ExecutarSeuMetodoParaLista(const Conexoes: TPoolConexoes);
  end;

implementation

uses
  System.Classes;

{ TPoolConexoes }

procedure TPoolConexoes.ExecutarSeuMetodoParaLista(const Conexoes: TPoolConexoes);
var
  conexao: TSocketConnection;
  threadAtual: TThread;
begin
  for conexao in Conexoes do
  begin
    threadAtual := TThread.CreateAnonymousThread(
      procedure
      begin
        Self.SeuMetodoQueUsaConexao(conexao);
      end
    );
    threadAtual.FreeOnTerminate := True;
    threadAtual.Start;
  end;

end;

function TPoolConexoes.NewConnection: TSocketConnection;
var
  conexaoTemp: TSocketConnection;
begin
  conexaoTemp := TSocketConnection.Create(nil);
  Self.Add(conexaoTemp);
  Result := conexaoTemp;
end;

function TPoolConexoes.ObterConexoesPorStatus(const aStatus: string): TPoolConexoes;
begin
  //sua logica aqui
end;

procedure TPoolConexoes.SeuMetodoQueUsaConexao(const aConexao: TSocketConnection);
begin
  //usa a conexao para fazer algo
end;

end.

You can still put all the created threads into a Threadlist and manage the end of them

Or you can extend the thread class to contain the execution code instead of using the Anonimos and keeping the threads in a pool that will run Ondemand

It all depends on your needs