Given one established tcp connection from client to server, is a second one resolved without server explicitly calling accept?

Question

Apologies in advance if my terminology is very rudimentary:

I am working with a client that establishes a tcp connection to a server. The client's socket is nonblocking, so after calling connect() , the client waits for the socket to become writable.

Upon accept() ing the connection from the client, the server performs a blocking operation (call it function X) and does not return to blocking at accept() for a long time.

During this time that the server is occupied performing function X, the client does another connect() to the same server, again using a nonblocking socket (different than the socket used with the first connection), then waiting for the socket to become writable in order to consider the tcp connection as "established."

I naively expected the second socket to remain not-writable until the server called accept() a second time to accept that second connection. But I've observed this as not the case: the second socket becomes writable quickly, so the client again considers this new tcp connection as "established."

Is this expected?

From one of the comments at this question , I (very loosely) understand that nonblocking sockets that are in the middle of a tcp connect will remain not-writable for the duration that TCP handshaking is being performed - is this true? Does this relate to the above question? Is it something like: if there is an existing tcp connection from a client to a server, then subsequent tcp connections from that same client to that same server are immediately/quickly "resolved" (the socket becomes writable without the server explicitly performing a second accept )?

What I tried :

I tried writing up a unit test to simulate this scenario with one thread each for client and server running on a single PC, but I think this is not a valid way to test: per this Q&A I think if client and server are on the same PC, "TCP handshaking" is not quite the same as with two separate PCs, and for example, the client's connecting socket becomes writable without the server even listening let alone accepting the connection.

Answer 1

Every connect() needs a corresponding accept() in order for client and server to communicate with each other.

However, it is possible/likely that the 3-way TCP handshake maybe/is completed while the connection is still in the server's backlog, before accept() creates a new socket for it. Once the handshake is complete, the connection is "established", and that will complete the connect() operation on the client's side, even if the connection has not been accept() ed yet on the server side.

See How TCP backlog works in Linux