Geekcattle Blog

To implement multithreaded downloading functionality in Android, follow these steps:

• Define Download Task: Create a download task class that includes the download URL, file save path, and download status information.
• Thread Pool Management: Use ExecutorService to manage the thread pool, which helps control the number of concurrent threads and improve resource utilization.
• File Segmentation: Divide the file into multiple parts, with each part downloaded by a separate thread. This enables parallel downloading and improves download speed.
• Thread Synchronization: Use synchronization tools like CountDownLatch, Semaphore, or CyclicBarrier to ensure all threads complete their download tasks before merging the files.
• File Merging: After all threads complete downloading, merge the downloaded file segments into a complete file.
• Error Handling and Retry Mechanism: Add exception handling and retry mechanisms to download threads to handle network instability or server issues.
• UI Updates: Update the UI on the main thread to display download progress and status.
• Network Permission: Ensure the network permission is added in AndroidManifest.xml: <uses-permission android:name="android.permission.INTERNET"/>.

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class MultiThreadDownloader {

    private static final int THREAD_COUNT = 3; // Adjust thread count as needed
    private static final ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);

    public static void downloadFile(String fileUrl, String saveFilePath) {
        long fileLength = getFileLength(fileUrl);
        long partLength = fileLength / THREAD_COUNT;
        List<Future<?>> futures = new ArrayList<>();

        for (int i = 0; i < THREAD_COUNT; i++) {
            final int threadNum = i;
            futures.add(executorService.submit(() -> {
                long start = partLength * threadNum;
                long end = (i == THREAD_COUNT - 1) ? fileLength : start + partLength - 1;
                downloadFilePart(fileUrl, saveFilePath, start, end);
            }));
        }

        for (Future<?> future : futures) {
            try {
                future.get();
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }

        executorService.shutdown();
    }

    private static long getFileLength(String fileUrl) {
        HttpURLConnection connection = null;
        try {
            URL url = new URL(fileUrl);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.connect();
            return connection.getContentLengthLong();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
        return 0;
    }

    private static void downloadFilePart(String fileUrl, String saveFilePath, long start, long end) {
        HttpURLConnection connection = null;
        try {
            URL url = new URL(fileUrl);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setReadTimeout(5000);
            connection.setConnectTimeout(5000);
            connection.connect();

            String range = "bytes=" + start + "-" + end;
            connection.setRequestProperty("Range", range);

            InputStream inputStream = connection.getInputStream();
            RandomAccessFile randomAccessFile = new RandomAccessFile(saveFilePath, "rw");
            randomAccessFile.seek(start);
            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                randomAccessFile.write(buffer, 0, bytesRead);
            }
            randomAccessFile.close();
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}

This example code demonstrates the basic framework for implementing multithreaded file downloading. In practical applications, you may need to adjust and optimize based on specific requirements.