Avoid unnecessary allocations by reusing a buffer

This change introduces the TusUploader#setChunkSize and TusUploader#uploadChunk
methods which replace and deprecate TusUploader#uploadChunk(int). Latter
method did not reuse the buffer resulting in a high number of memory allocations.

Author: Acconut

README.md

@@ -34,9 +34,12 @@ TusUpload upload = new TusUpload(file);
 // a connection to the remote server and doing the uploading.
 TusUploader uploader = client.resumeOrCreateUpload(upload);
 
-// Upload the file in chunks of 1MB as long as data is available. Once the
+// Upload the file in chunks of 1MB sizes.
+uploader.setChunkSize(1024 * 1024);
+
+// Upload the file as long as data is available. Once the
 // file has been fully uploaded the method will return -1
-while(uploader.uploadChunk(1024 * 1024) > -1) {
+while(uploader.uploadChunk() > -1) {
   // Calculate the progress using the total size of the uploading file and
   // the current offset.
   long totalBytes = upload.getSize();

example/src/main/java/io/tus/java/example/Main.java

@@ -34,9 +34,12 @@ public static void main(String[] args) {
 
             System.out.println("Starting upload...");
 
-            // Upload the file in chunks of 1KB as long as data is available. Once the
+            // Upload the file in chunks of 1KB sizes.
+            uploader.setChunkSize(1024);
+
+            // Upload the file as long as data is available. Once the
             // file has been fully uploaded the method will return -1
-            while (uploader.uploadChunk(1024) > -1) {
+            while(uploader.uploadChunk() > -1) {
                 // Calculate the progress using the total size of the uploading file and
                 // the current offset.
                 long totalBytes = upload.getSize();

src/main/java/io/tus/java/client/TusUploader.java

@@ -25,6 +25,7 @@ public class TusUploader {
     private URL uploadURL;
     private InputStream input;
     private long offset;
+    private byte[] buffer;
 
     private HttpURLConnection connection;
     private OutputStream output;
@@ -46,6 +47,8 @@ public TusUploader(TusClient client, URL uploadURL, InputStream input, long offs
 
         input.skip(offset);
 
+        setChunkSize(2 * 1024 * 1024);
+
         connection = (HttpURLConnection) uploadURL.openConnection();
         client.prepareConnection(connection);
         connection.setRequestProperty("Upload-Offset", Long.toString(offset));
@@ -63,6 +66,60 @@ public TusUploader(TusClient client, URL uploadURL, InputStream input, long offs
         output = connection.getOutputStream();
     }
 
+    /**
+     * Sets the used chunk size. This number is used by {@link #uploadChunk()} to indicate how
+     * much data is uploaded in a single take. When choosing a value for this parameter you need to
+     * consider that uploadChunk() will only return once the specified number of bytes has been
+     * sent. For slow internet connections this may take a long time. In addition, a buffer with
+     * the chunk size is allocated and kept in memory.
+     *
+     * @param size The new chunk size
+     */
+    public void setChunkSize(int size) {
+        buffer = new byte[size];
+    }
+
+    /**
+     * Returns the current chunk size set using {@link #setChunkSize(int)}.
+     *
+     * @return Current chunk size
+     */
+    public int getChunkSize() {
+        return buffer.length;
+    }
+
+    /**
+     * Upload a part of the file by reading a chunk from the InputStream and writing
+     * it to the HTTP request's body. If the number of available bytes is lower than the chunk's
+     * size, all available bytes will be uploaded and nothing more.
+     * No new connection will be established when calling this method, instead the connection opened
+     * in the constructor will be used.
+     * The size of the read chunk can be obtained using {@link #getChunkSize()} and changed
+     * using {@link #setChunkSize(int)}.
+     * In order to obtain the new offset, use {@link #getOffset()} after this method returns.
+     *
+     * @return Number of bytes read and written.
+     * @throws IOException  Thrown if an exception occurs while reading from the source or writing
+     *                      to the HTTP request.
+     */
+    public int uploadChunk() throws IOException {
+        int bytesRead = input.read(buffer);
+        if(bytesRead == -1) {
+            // No bytes were read since the input stream is empty
+            return -1;
+        }
+
+        // Do not write the entire buffer to the stream since the array will
+        // be filled up with 0x00s if the number of read bytes is lower then
+        // the chunk's size.
+        output.write(buffer, 0, bytesRead);
+        output.flush();
+
+        offset += bytesRead;
+
+        return bytesRead;
+    }
+
     /**
      * Upload a part of the file by read a chunks specified size from the InputStream and writing
      * it to the HTTP request's body. If the number of available bytes is lower than the chunk's
@@ -71,6 +128,12 @@ public TusUploader(TusClient client, URL uploadURL, InputStream input, long offs
      * in the constructor will be used.
      * In order to obtain the new offset, use {@link #getOffset()} after this method returns.
      *
+     * @deprecated This method is inefficient and has been replaced by {@link #setChunkSize(int)}
+     *             and {@link #uploadChunk()} and should not be used anymore. The reason is, that
+     *             this method allocates a new buffer with the supplied chunk size for each time
+     *             it's called without reusing it. This results in a high number of memory
+     *             allocations and should be avoided. The new methods do not have this issue.
+     *
      * @param chunkSize Maximum number of bytes which will be uploaded. When choosing a value
      *                  for this parameter you need to consider that the method call will only
      *                  return once the specified number of bytes have been sent. For slow
@@ -79,9 +142,9 @@ public TusUploader(TusClient client, URL uploadURL, InputStream input, long offs
      * @throws IOException  Thrown if an exception occurs while reading from the source or writing
      *                      to the HTTP request.
      */
-    public int uploadChunk(int chunkSize) throws IOException {
-        byte[] buffer = new byte[chunkSize];
-        int bytesRead = input.read(buffer);
+    @Deprecated public int uploadChunk(int chunkSize) throws IOException {
+        byte[] buf = new byte[chunkSize];
+        int bytesRead = input.read(buf);
         if(bytesRead == -1) {
             // No bytes were read since the input stream is empty
             return -1;
@@ -90,7 +153,7 @@ public int uploadChunk(int chunkSize) throws IOException {
         // Do not write the entire buffer to the stream since the array will
         // be filled up with 0x00s if the number of read bytes is lower then
         // the chunk's size.
-        output.write(buffer, 0, bytesRead);
+        output.write(buf, 0, bytesRead);
         output.flush();
 
         offset += bytesRead;

src/test/java/io/tus/java/client/TestTusUploader.java

@@ -53,9 +53,13 @@ public void testTusUploader() throws IOException, ProtocolException {
         long offset = 3;
 
         TusUploader uploader = new TusUploader(client, uploadUrl, input, offset);
-        assertEquals(5, uploader.uploadChunk(5));
+
+        uploader.setChunkSize(5);
+        assertEquals(uploader.getChunkSize(), 5);
+
+        assertEquals(5, uploader.uploadChunk());
         assertEquals(3, uploader.uploadChunk(5));
-        assertEquals(-1, uploader.uploadChunk(5));
+        assertEquals(-1, uploader.uploadChunk());
         assertEquals(11, uploader.getOffset());
         uploader.finish();
     }