AWS S3 `getObject` in java is slower than python's

I've noticed that using the getObject method in the AWS SDK v2 in Java is slower than using the getObject method in the boto3 library in python.

Setup: I am reading a 1GB file stored in a S3 bucket in us-east-1. I use a i3en.2xlarge EC2 instance in a VPC with an Endpoint gateway for S3. The VM is located in us-east-1 too. I used the same EC2 VM to execute the python and java benchmarks, so I think I can discard deployment or setup problems. OS: Ubuntu 22.04

Java 11, AWS SDK v2.29.25 Python 3.10.12, boto3 v1.35.54

Java code:

import software.amazon.awssdk.core.ResponseBytes;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;

import java.time.Duration;
import java.time.Instant;

public class TestS3 {

    public static void main(String[] args) {
        String bucket = args[0];
        String key = args[1];
    
        Instant t0 = Instant.now();
        S3Client client = S3Client.builder().build();
        GetObjectRequest request = GetObjectRequest.builder()
                .bucket(bucket)
                .key(key)
                .build();
    
        ResponseBytes responseBytes = client.getObjectAsBytes(request);
        byte [] data = responseBytes.asByteArray();
        Instant t1 = Instant.now();
        int size = data.length;
        Duration duration = Duration.between(t0, t1);
        double throughput = (double) size / duration.toSeconds();

        System.out.println("Time to read: " + duration.toSeconds() + " s");
        System.out.println("Size: " + size + " B");
        System.out.println("Size: " + size / (1024.0 * 1024.0) + " MB");
        System.out.println("Throughput: " + throughput + " B/s");
        System.out.println("Throughput: " + throughput / (1024.0 * 1024.0) + " MB/s");
        
    }
}

Python code:

import sys
import time
import boto3

bucket = sys.argv[1]
key = sys.argv[2]

t0 = time.time()
client = boto3.client('s3')
obj = client.get_object(Bucket=bucket, Key=key)
data = obj['Body'].read()
t1 = time.time()

size = len(data)
throughput = size / (t1 - t0)
print(f"Time to read: {t1 - t0} s")
print(f"Size: {size} B")
print(f"Size: {size / (1024 * 1024)} MB")
print(f"Throughput: {throughput} B/s")
print(f"Throughput: {throughput / (1024 * 1024)} MB/s")

Java results (3 runs):

# Run 1
Time to read: 18.369 s
Size: 1073741824 B
Size: 1024.0 MB
Throughput: 5.845401622298437E7 B/s
Throughput: 55.74609396265447 MB/s

# Run 2
Time to read: 13.227 s
Size: 1073741824 B
Size: 1024.0 MB
Throughput: 8.117803160202615E7 B/s
Throughput: 77.41740379526725 MB/s

# Run 3
Time to read: 15.643 s
Size: 1073741824 B
Size: 1024.0 MB
Throughput: 6.86404029917535E7 B/s
Throughput: 65.46058940101004 MB/s

Python results (3 runs):

# Run 1
Time to read: 13.131076335906982 s
Size: 1073741824 B
Size: 1024.0 MB
Throughput: 81771044.24135046 B/s
Throughput: 77.98294471869512 MB/s

# Run 2
Time to read: 10.911798000335693 s
Size: 1073741824 B
Size: 1024.0 MB
Throughput: 98401915.42832512 B/s
Throughput: 93.84337942917358 MB/s

# Run 3
Time to read: 10.976710796356201 s
Size: 1073741824 B
Size: 1024.0 MB
Throughput: 97819997.62227829 B/s
Throughput: 93.28841936328725 MB/s

Comments: There is an approximate gap in the performance of 30 MB/s. The results of the python benchmark are the same as the AWS CLI with the configuration max_concurrent_requests = 1, which makes sense, because, as far as I know, the CLI is implemented in python.