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

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

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

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

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

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

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

Android下推荐开启： ~ 线程。

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，发现是可以播放的。