如何使用Indy建立双向TCP连接？

Question

I use TIdTCPClient and TIdTCPServer (with my own protocol) and I want to make a TCP connection in which both computers can send commands and read replays. Of course, one will be server and the other client, but just until the connection is established, after that, they both must be "servers and clients". I don't know how to explain this more clearly... Mainly, computer "A" will send commands to computer "B", but sometimes, some events happen on the computer "B" and must be communicated immediately to computer "A". So, every computer should listen all the time for commands, but in the same time it must be able to send some commands when the events are happening.

For sending commands it's simple: just write something to the socket. But to be able to replay them, the application must read from socket, and if it read, it can't write.... I searched the internet and I found here and here some answers to similar questions, in which is said that should be used 2 threads, one for writing and one for reading. But I don't understand how cand I use the same object, the connection socket, in 2 threads... What if one thread reads something that is changed by the other (the basic thread problem) ?

I have made some tests with a chat application with the following code and it seems it's working fine but I'm not sure if this is the correct way to do it... I mean, to create a connection and after that pass the socket object to two threads, one for read and one for write.

constructor TReadingThread.Create(ASocket: TIdIOHandlerSocket);
begin
  FSocket := ASocket;
  inherited Create(False);
end;

procedure TReadingThread.Execute;
var
  cmd: string;
begin
  while not Terminated do
  begin
    cmd := FSocket.ReadLn;
    Trim(cmd);
    if cmd <> '' then
    Synchronize(
    procedure
    begin
      Form1.Display.Lines.Add(cmd);
    end);
  end;
end;

procedure TForm1.BConnectClick(Sender: TObject);
begin
 TCPClient.Connect;
end;

procedure TForm1.InputKeyPress(Sender: TObject; var Key: Char);
begin
 if Key=#13 then begin
  TCPClient.Socket.WriteLn(Input.Text);
  Input.Clear;
  Key:=#0;
 end;
end;

procedure TForm1.TCPClientConnected(Sender: TObject);
begin
 readthread:= TReadingThread.Create(TCPClient.Socket);
 Display.Lines.Add('Server: Connected.');
end;

Answer 1

computer "A" will send commands to computer "B", but sometimes, some events happen on the computer "B" and must be communicated immediately to computer "A". So, every computer should listen all the time for commands, but in the same time it must be able to send some commands when the events are happening.

When A sends a command to B, or vice versa, it has no way of knowing whether the next message received will be a response to the command or an unsolicited event. So it can't just send a command and sit waiting for the response, as it may receive other messages in the meantime. You will have to read messages asynchronously and handle them on a per-message basis as they arrive.

To help facilitate this, every message must identify what it is (command, response, or event). When a command is sent, the sender should include a user-defined value in it that is echoed back in the response. This will allow the sender to correlate response to commands, and even to have multiple commands in flight at the same time. Unsolicited events would not have a user-defined value in them, as they don't get a response.

This way, events can then be sent at any time, and when a command is received it can be processed in parallel to anything else, and a response sent back whenever it is ready (even out of order of other commands, if desired).

For sending commands it's simple: just write something to the socket. But to be able to replay them, the application must read from socket, and if it read, it can't write....

Yes, it can. You just can't do it in the same thread, if the thread is blocked doing other things.

I searched the internet and I found here and here some answers to similar questions, in which is said that should be used 2 threads, one for writing and one for reading.

Yes, that is one solution, and the one you will likely end up using with Indy, given its blocking nature. But it is not the only solution when working with sockets in general, there are better solutions (overlapped I/O, etc).

But I don't understand how cand I use the same object, the connection socket, in 2 threads...

What makes you think it can't be shared? A socket has separate inbound and outbound buffers. One thread can be reading inbound data while another thread is writing outbound data at the same time. They will not interfere with each other.

What if one thread reads something that is changed by the other (the basic thread problem) ?

Nothing is being changed on the reading side while the writing side is working, and vice versa.

What you have to watch out for is multiple threads reading from the socket at the same time, or multiple threads writing to the socket at the same time. That is not safe without adequate synchronization between the threads. But one thread reading while one thread is writing is perfectly safe without synchronizing the two threads.

I have made some tests with a chat application with the following code and it seems it's working fine but I'm not sure if this is the correct way to do it... I mean, to create a connection and after that pass the socket object to two threads, one for read and one for write.

That is perfectly fine. Just make sure the reading thread is terminated before the connection object is destroyed.