為什麼要多線程下載

俗話說要以終為始，那麼我們首先要明確多線程下載的目標是什麼，不外乎是為了更快的下載文件。那麼問題來了，多線程下載文件相比於單線程是不是更快?

對於這個問題可以看下圖。

橫坐標是線程數，縱坐標是使用對應線程數下載對應文件時花費的時間，藍橙綠代表下載文件的大小，每個線程下載對應文件20次，根據對應數據繪製了上圖。

可以看出在忽略個別網路波動出現的突出點後，整體的趨勢是線程數量的提升對下載速度沒有多大影響。根據上述圖片可以得出的結論是，單線程下載就夠了，還需要多線程下載幹嘛？既沒有提升還增加麻煩。

根據目前測試結果來看這個結論是沒有問題的。那我們試著在分析下問題，想一想此時為什麼多線程下載沒有作用？可以看下橙色線條下載文件為55M左右，下載時間平均在5s左右,平均下載速度大概為11M左右，還有綠色線條文件大概224M，下載速度平均為20s，平均下載速度大概在11M左右。而我本地網路是100M寬頻，實際下行速率的上限是12.5M，可以看出下載速度已經逼近下行峰值。此時無論是單個線程還是多個線程都可以將下載帶寬跑滿，那麼即使是開多個線程也不能把本地帶寬提高，你也不能把本地100M帶寬變成300M，所以這裡使用多線程進行下載速度基本不可能提升了，除非我換寬頻加到300M或更大。這裡可以看出是本地帶寬限制了下載速度。

由此我們可以得出結論，下載速度由本地帶寬決定，本地帶寬已經跑滿的情況下，下載速度無法進行提升，這個也比較符合我們的正常邏輯，網速不夠怎麼辦，換更大的帶寬，速度自然提升，當然也意味著交更多的錢....。

那麼問題真的是如此嗎，比如我們知道的某網盤，管你本地帶寬多大，我都只有幾十或幾百k的下載速度。你強任你強，你能跑滿帶寬算我輸！！！當然開VIP還是可以享受加速服務的，加速二字劃重點。
此時可以看出是伺服器端限制了下載速度，即使我本地有很大帶寬但依然跑不滿。那麼這個時候我上多線程會有提升嗎？可以看下圖。

這是一個下載文件限速的網址，使用不同線程數進行下載,根據線程數和下載花費時間繪製的圖片。可以看到隨著線程數的增加，下載速度顯著提升，一個線程情況下55M文件下載了550s左右，平均速度為100k每秒，100個線程下載大概需要6秒，平均速度大概為9M每秒，加上線程創建請求等開銷基本逼近本地帶寬上限。

由上述可知，在伺服器不限速或者說伺服器的傳輸速度大於等於本地帶寬的情況下，單線程下載足矣。在伺服器對單個連接下載限速時，使用多線程可以提升下載速度。但伺服器本身的帶寬也是有限的，例如伺服器帶寬為300M，下載速度可達37.5M/s.這時有多個用戶在進行下載，此時可能開了多線程也不會有太大收益，伺服器本身帶寬已經很緊張了，你也不能無中生有，突破帶寬本身的上限。就有點像搶票軟體，資源沒那麼緊張的使用搶票軟體有一定提升可以方便搶到，等到春運時即使用搶票軟體搶，也很難搶到票。

前置條件

上述說明瞭在什麼時候可以快的問題。可以看出在特定情況下還是有收益的，既然有收益，那麼就值得我們去做。既然要做那麼就面臨第一個問題，能不能做？怎麼做是第二步，第一步首先要考慮能不能做的問題，違法的事情當然不能做，受客觀條件限制目前做不了的事也不能做。

那麼首先可以想一想多線程下載的大概思路，一個線程下載一部分，然後將所有下載好的內容組裝再一次。比如一個文件有2kb(2048byte)，一共兩個線程下載，第一個線程下載第一個1kb，第二個線程下載第二個1kb,然後將第一個下載好的1kb寫入文件，接著將下載好的第二個1kb寫入文件，下載完成。

實現上述流程，向伺服器請求時，伺服器必須能返回下載文件指定範圍的數據。也就是說伺服器需要支持http請求中的關鍵字Range.Range的常規格式為Range : bytes=start-end其中start表示起始位元組，end表示結束位元組，start和end位都包含在內，既左右都是閉區間 [start,end]，如bytes=0-1表示第0個位元組和第1個位元組，一共2個位元組。如一個文件大小為10byte,分三個線程線程下載那麼三個請求的Range分別為bytes=0-2,bytes=3-5,bytes=6-9.分別下載3byte,3byte,4byte.

那麼如何確定伺服器是否支持Range呢，你可以對下載文件發送一個帶Range的請求，可以將請求頭中Ragne設置為bytes=0-0.看返回的狀態碼是否為206.如果時206表示支持Ragne，並且返回的響應頭中也會有Content-Range欄位標識當前請求的位元組範圍，文件總大小。例如文件大小為55118504byte,請求bytes=0-0,會返回一個Content-Range : bytes 0-0/55118504.

可以使用postman發送請求判斷

也可以使用java判斷是否支持Range

public static boolean supportRange(String urlPath) throws IOException {
        URL url = new URL(urlPath);
        URLConnection urlConnection = url.openConnection();
        urlConnection.setRequestProperty("Range", "bytes=0-0");
        return ((HttpURLConnection) urlConnection).getResponseCode() == HttpURLConnection.HTTP_PARTIAL;//206
    }

如果伺服器不支持Range,那就沒辦法呢，老老實實用單線程下載，畢竟巧婦難為無米之炊。

主要步驟

首先肯定是判斷伺服器支不支持Range,在支持的基礎上首先獲取文件長度，然後將文件長度根據線程數計算每個線程的請求範圍。然後所有線程去發送請求，請求結束後將返回結果組裝，大功告成。

這裡需要註意下載後數據組裝順序的問題，多線程發送請求下載指定範圍的數據，可能最後一部分數據最先返回，這時需要註意數據應寫入下載後文件對應位置。不能把最後10個位元組寫入開始位置，同樣開始10個位元組也不能寫到文件其他位置上。

具體代碼

在編寫代碼前，需要最好找一個對下載限速的網站，測試開啟多線程後的提升。本來想試下某盤的，結果折騰半天還是沒有拿到真實下載地址，後來經過很長（查找不易，歡迎點贊）時間的查找，發現 這個網站的歷史軟體版本下載是限速的，進入具體軟體下載頁面後，不要點頁面開始位置的本地純凈下載（這個是不限速的），拉到頁面下方點擊歷史版本下載中的本地下載，然後在chrome瀏覽器的下載管理中複製的下載鏈接進行測試的，希望大家文明測試下載。

package org.hcf.utils;

import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.math.BigDecimal;
import java.net.*;
import java.util.*;
import java.util.concurrent.*;

@Slf4j
public class FileUtils {

    /**
     * 多線程下載指定文件，寫入outputStream中
     * @param fileUrl 文件路徑
     * @param executor 線程池，根據線程池核心線程數量創建下載請求，如線程池核心線程數為3，創建3個下載請求。
     * @param outputStream 下載文件輸出流
     * @throws IOException
     * @throws URISyntaxException
     * @throws InterruptedException
     */
    public static void fileMultithreadingDownload(String fileUrl, ThreadPoolExecutor executor, OutputStream outputStream) throws IOException, URISyntaxException, InterruptedException {
        if (!supportRange(fileUrl)) {
            throw new UnsupportedOperationException("unsupported operation exception");
        }

        long startTime = System.currentTimeMillis();

        // 獲取下載文件大小
        long contentLengthLong = getContentLengthLong(fileUrl);

        // 根據核心線程數，計算請求數據大小。
        int corePoolSize = executor.getCorePoolSize();
        // 如contentLengthLong(文件長度)=10  下載線程數(corePollSize)=3。
        //requestSize = 向上取整((10 / 3)) = 4
        int requestSize = new BigDecimal(String.valueOf(Math.ceil(contentLengthLong / (corePoolSize + 0.0)))).intValue();

        //根據文件每次請求數據大小和文件大小，計算請求範圍。
        //如requestSize = 4， contentLengthLong = 10，requestRanges=[0-3, 4-7, 8-9]
        List<String> rangeList = getRangeSize(contentLengthLong, requestSize);
        CountDownLatch countDownLatch = new CountDownLatch(rangeList.size());
        Map<Long, byte[]> result = new ConcurrentHashMap<>();

        //rangeList = [0-3, 4-7, 8-9],多線程請求對應範圍數據
        for (String range : rangeList) {
            executor.execute(() -> {
                Long start = Long.valueOf(range.split("-")[0]);
                //獲取文件指定range數據,並用範圍起始位置作為key,用於後續排序組裝。
                result.put(start, getRangeDataByFile(fileUrl, range));
                //下載完成一個range,計數-1
                countDownLatch.countDown();
            });
        }

        //等待所有線程下載完成後組合
        countDownLatch.await();
        //根據result的key升序順序將數據寫入輸出流
        new ArrayList<>(result.keySet()).stream()
                .sorted()
                .forEach(e ->
                        ExceptionRound.execute(() ->
                                outputStream.write(result.get(e)))
                );
        outputStream.flush();
        outputStream.close();

        long timer = System.currentTimeMillis() - startTime;
        log.info("{},{},{}", contentLengthLong, corePoolSize, timer);
    }


    /**
     * 獲取文件指定range數據
     *
     * @param fileUrl 文件路徑
     * @param range   指定範圍 如 range = 0-3 ,獲取文件第開頭4個位元組
     * @return
     */
    private static byte[] getRangeDataByFile(String fileUrl, String range) {
        return ExceptionRound.execute(() -> {
            URL url = new URL(fileUrl);
            HttpURLConnection downloadConnection = (HttpURLConnection) url.openConnection();
            downloadConnection.setRequestMethod("GET");
            downloadConnection.setRequestProperty("Range", String.format("bytes=%s", range));
            InputStream inputStream = downloadConnection.getInputStream();

            byte[] byt = new byte[4096];
            int readSize;
            ByteArrayOutputStream tempOutput = new ByteArrayOutputStream();
            while ((readSize = inputStream.read(byt)) != -1) {
                tempOutput.write(byt, 0, readSize);
            }
            inputStream.close();
            return tempOutput.toByteArray();
        });
    }


    /**
     * 獲取文件長度
     * @param fileUrl
     * @return
     * @throws IOException
     */
    public static long getContentLengthLong(String fileUrl) throws IOException {
        URL url = new URL(fileUrl);
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        urlConnection.setRequestMethod("HEAD");
        urlConnection.setRequestProperty("Accept-Encoding", "identity");
        long contentLengthLong = urlConnection.getContentLengthLong();
        urlConnection.disconnect();
        return contentLengthLong;
    }

    /**
     * 獲取請求range列表
     * 如contentLengthLong = 10，requestSize = 4，
     * result[0-3, 4-7, 8-9]
     * @param contentLengthLong 文件總長度
     * @param requestSize 每次下載位元組數
     * @return
     */
    private static List<String> getRangeSize(long contentLengthLong, int requestSize) {
        LinkedList<String> result = new LinkedList<>();
        for (long start = 0; start < contentLengthLong; ) {
            long end = Math.min((start + (requestSize - 1)), contentLengthLong - 1);
            result.add(String.format("%d-%d", start, end));
            start = end + 1L;
        }
        return result;
    }

    /**
     * 判斷是否支持range請求頭
     * @param urlPath
     * @return
     * @throws IOException
     */
    public static boolean supportRange(String urlPath) throws IOException {
        URL url = new URL(urlPath);
        URLConnection urlConnection = url.openConnection();
        urlConnection.setRequestProperty("Range", "bytes=0-0");
        return ((HttpURLConnection) urlConnection).getResponseCode() == HttpURLConnection.HTTP_PARTIAL;
    }
}

/**
 * 使用 ExceptionRound.execute包裹代碼，避免try catch
 */
@Slf4j
class ExceptionRound {
    public static <T> T execute(SupplierExecute<T> command) {
        try {
            return command.get();
        } catch (Exception e) {
            log.error("exception", e);
            throw new UnsupportedOperationException(e);
        }
    }

    public static void execute(Execute command) {
        try {
            command.execute();
        } catch (Exception e) {
            log.error("exception", e);
        }
    }

    interface Execute {
        void execute() throws Exception;
    }

    interface SupplierExecute<T> {
        T get() throws Exception;
    }
}

package org.hcf.utils;

import org.junit.Test;
import org.springframework.util.Assert;

import java.io.*;
import java.net.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAccessor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class FileUtilsTest {


    @Test
    public void shouldMultithreadingDownloadFile() throws InterruptedException, IOException, URISyntaxException {
        int threadNumber = 40;
        String downloadFileUrl = "xxxxxxx";

        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(threadNumber, threadNumber, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
        FileUtils.fileMultithreadingDownload(downloadFileUrl, executor, outputStream);

        String downloadFile = "D:\\temp\\" + dateFormat(LocalDateTime.now(), "yyyy-MM-dd_hh-mm-ss-SSS") + ".exe";
        outputFile(outputStream, downloadFile);

        Assert.isTrue(new File(downloadFile).length() == FileUtils.getContentLengthLong(downloadFileUrl), "file download fail");
    }


    private String dateFormat(TemporalAccessor dateTime, String format) {
        return DateTimeFormatter.ofPattern(format).format(dateTime);
    }


    private void outputFile(ByteArrayOutputStream outputStream, String filePath) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream(new File(filePath));
        fileOutputStream.write(outputStream.toByteArray());
        fileOutputStream.flush();
        fileOutputStream.close();
    }
}