Android（java）学习笔记158：多线程断点下载的原理（JavaSE实现）

1. 为什么需要多线程下载?

    服务器的资源有限，同时的平均地分配给每个客户端。开启的线程越多抢占的服务的资源就越多，下载的速度就越块。

2. 下载速度的限制条件？

（1）你的电脑手机宽带的带宽。（网络运营商给用户的限制）

（2）服务器上传的带宽限制。 （服务器端资源获取速度的限制）----迅雷， p2p快播等下载，可以同时间使用多台服务器帮助用户下载资源，速度自然会加快。

注意：并不是开的线程越多下载速度越快，可能会消耗大量时间在线程调度上。

Android下推荐开启：3 ~ 5线程。

3. 如何进行多线程的下载：

（1）在客户端本地创建一个空文件（申请一块内存），大小要和服务器上要下载的资源一样.

（2）开启3个线程，都去下载服务器的数据.

（3）当三个线程都工作完毕后，多线程的下载就结束了.

 这里特别注意最后一个线程需要修正，主要是因为不可能实现完全等分，具体如下：

 

4.JavaSE代码实现多线程下载：

 （1）我们可以先编写java项目工程，调试实现多线程下载逻辑类MutilDownloader.java：

 

 （2）打开Apache服务器，在相应的目录下存放测试下载文件，如下：

（3）MutilDownloader.java，如下：

package com.himi.mutildownload;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * 多线程的下载器
 *
 */
public class MutilDownloader {
    /**
     * Apache服务器上资源下载的路径
     */
    private static final String path = "http://49.123.76.170/movies/test.avi";
    /**
     * 多少个线程去下载服务器的资源
     */
    private static int threadCount = 4;

    /**
     * 正在运行的线程的数量
     */
    private static int runningThreadCount;

    public static void main(String[] args) throws Exception {
        URL url = new URL(path);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        int code = conn.getResponseCode();
        if (code == 200) {
            int length = conn.getContentLength();
            System.out.println("服务器文件的大小为：" + length);

            // 1. 创建一个空白文件文件的大小和服务器资源一样
            RandomAccessFile raf = new RandomAccessFile(getFileName(path), "rw");
            raf.setLength(length);
            raf.close();

            // 每个线程下载的平均区块大小
            int blocksize = length / threadCount;
            System.out.println("每一份：" + blocksize);

            runningThreadCount = threadCount;
            // 2. 开启3个线程，都去下载服务器的对应数据
            for (int threadId = 0; threadId < threadCount; threadId++) {
                int startIndex = threadId * blocksize;
                int endIndex = (threadId + 1) * blocksize - 1;

                // 最后一个线程的修正，最后一个线程endIndex设置为文件末尾
                if (threadId == (threadCount - 1)) {
                    endIndex = length - 1;// 文件byte是从0开始计数的
                }

                new DownloadThread(startIndex, endIndex, threadId).start();
            }
        }

        // 3. 当三个线程都工作完毕后，多线程的下载就结束了.

    }

    public static class DownloadThread extends Thread {
        /**
         * 线程id
         */
        int threadId;

        /**
         * 当前线程下载的开始位置
         */
        int startIndex;
        /**
         * 当前线程下载的结束位置
         */
        int endIndex;

        /**
         * 当前线程下载到文件的位置
         */
        int filePosition;

        /**
         * 
         * @param startIndex
         *            开始位置
         * @param endIndex
         *            结束位置
         * @param threadId
         *            线程id
         */
        public DownloadThread(int startIndex, int endIndex, int threadId) {
            this.startIndex = startIndex;
            this.endIndex = endIndex;
            this.threadId = threadId;
            filePosition = startIndex;
        }

        @Override
        public void run() {
            try {
                // 用一个文本记录当前线程下载的进程
                File file = new File(threadId + getFileName(path) + ".txt");

                if (file.exists() && file.length() > 0) {
                    FileInputStream fis = new FileInputStream(file);
                    BufferedReader br = new BufferedReader(new InputStreamReader(fis));
                    filePosition = Integer.parseInt(br.readLine());// 上一次下载到文件的哪个位子。
                    startIndex = filePosition;
                    fis.close();
                }

                System.out.println("线程：" + threadId + "实际上下载的位置：" + startIndex + "~~~" + endIndex);

                URL url = new URL(path);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                // 指定从服务器下载的范围，http请求的头
                conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);

                int code = conn.getResponseCode();// 2XX成功 3XX重定向 4XX资源找不到
                                                    // 5XX服务器异常
                if (code == 206) {// 206:表示请求部分数据成功
                    // 返回服务器端对应数据的输入流
                    InputStream is = conn.getInputStream();
                    RandomAccessFile raf = new RandomAccessFile(getFileName(path), "rwd");

                    /**
                     * ☆☆☆☆☆非常重要☆☆☆☆☆ 一定要记得定位文件写的位置
                     * 不同线程在文件中（代码开头：创建的空文件）开始写入的位置是不一样的
                     */
                    raf.seek(startIndex);
                    byte[] buffer = new byte[1024 * 1024 * 10];
                    int len = -1;
                    while ((len = is.read(buffer)) != -1) {
                        raf.write(buffer, 0, len);
                        filePosition += len;
                        RandomAccessFile rafinfo = new RandomAccessFile(file, "rwd");
                        rafinfo.write(String.valueOf(filePosition).getBytes());
                        rafinfo.close();
                    }
                    raf.close();
                    is.close();

                    System.out.println("线程:" + threadId + "下载完毕了。");

                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {

                // 三个线程都结束了，下载完毕
                synchronized (MutilDownloader.class) {
                    runningThreadCount--;
                    if (runningThreadCount == 0) {
                        System.out.println("所有的线程都下载完毕了");
                        for (int i = 0; i < threadCount; i++) {
                            File f = new File(i + getFileName(path) + ".txt");
                            System.out.println(f.delete());
                        }
                    }
                }
            }
        }
    }

    /**
     * 获取路径对应的文件名
     * 
     * @param path
     * @return
     */
    private static String getFileName(String path) {
        int beginIndex = path.lastIndexOf("/") + 1;
        return path.substring(beginIndex);
    }

}

需要特别注意的是：RandomAccessFile.seek(startIndex)，它是用来定位文件写入的位置。

运行程序，观察Console，如下：

刷新Java工程项目，如下：

双击打开test.avi，发现是可以播放的。