Efficient HTTP Connection Reuse in Go

Connection reuse is a crucial optimization technique for HTTP clients, significantly reducing latency and improving performance by avoiding the overhead of establishing new connections for each request. This challenge asks you to implement a simple HTTP client that demonstrates and utilizes connection reuse, ensuring that connections are kept alive and reused for multiple requests to the same host.

Problem Description

You are tasked with creating a Go program that makes multiple HTTP requests to a specified URL. The program should leverage connection reuse to minimize the overhead of establishing new TCP connections for each request. The core requirement is to demonstrate that the client reuses existing connections when making subsequent requests to the same host and port. You should use the net/http package and its Transport to achieve this.

Specifically, you need to:

1. Create an http.Client with a custom Transport.
2. Configure the Transport to have a non-zero MaxIdleConnsPerHost value. This is the key to enabling connection reuse.
3. Make multiple HTTP GET requests to the same URL.
4. Verify (through logging or other means) that the same connection is reused for subsequent requests. A simple way to verify is to print the connection ID for each request.
5. Handle potential errors gracefully.

Edge cases to consider:

• What happens if the server closes the connection? The client should handle this and potentially establish a new connection.
• What happens if the MaxIdleConnsPerHost is reached? The client should queue requests until a connection becomes available.
• What happens if the URL changes to a different host? A new connection should be established.

Examples

Example 1:

Input: URL = "https://www.example.com", Number of Requests = 3
Output: (Console output showing connection IDs)
Request 1: Connection ID: 12345
Request 2: Connection ID: 12345
Request 3: Connection ID: 12345
Explanation: The same connection (ID 12345) is reused for all three requests to example.com.  The actual ID will vary.

Example 2:

Input: URL = "https://www.example.com", Number of Requests = 2, then URL = "https://www.google.com", Number of Requests = 2
Output: (Console output showing connection IDs)
Request 1: Connection ID: 12345
Request 2: Connection ID: 12345
Request 3: Connection ID: 67890
Request 4: Connection ID: 67890
Explanation: The first two requests reuse a connection to example.com.  The subsequent two requests to google.com establish a new connection.

Example 3: (Edge Case - Server closes connection)

Input: URL = "https://www.example.com", Number of Requests = 5 (assuming server closes connection after 3 requests)
Output: (Console output showing connection IDs)
Request 1: Connection ID: 12345
Request 2: Connection ID: 12345
Request 3: Connection ID: 12345
Request 4: Connection ID: 98765
Request 5: Connection ID: 98765
Explanation: The server closes the initial connection after 3 requests, forcing the client to establish a new connection.

Constraints

• The program must be written in Go.
• The net/http package must be used.
• MaxIdleConnsPerHost must be set to a value greater than 0 (e.g., 2 or 5).
• The program should handle errors gracefully and avoid panics.
• The program should be reasonably efficient and avoid unnecessary delays. While performance is not the primary focus, avoid extremely inefficient approaches.
• The URL must be a valid HTTP or HTTPS URL.

Notes

• Connection IDs are not directly exposed by the net/http package. You can use techniques like inspecting the underlying TCPConn to obtain connection IDs, but this is not strictly required. Focus on demonstrating that the same connection is reused. Printing the Transport.RoundTrip function's return value can sometimes provide clues about connection reuse.
• Consider using goroutines to make the requests concurrently to better simulate real-world scenarios.
• The KeepAlive setting on the Transport is also relevant to connection reuse, but MaxIdleConnsPerHost is the primary setting to focus on for this challenge.
• The server you are connecting to must support keep-alive connections for this to be effective. Most modern web servers do.