【0042】Android基础-30-JavaSE多线程下载(重要)

【概述】

  首先使用JavaSE书写一个多线程下载的实例，然后将该实例移植到Android中；

【1】步骤

【2】获取要下载的文件的大小

 

【3】设置随机文件的大小

 在本地磁盘新建一个与要下载的文件大小相同的空文件；

 

【4】要分配每个线程下载文件的开始位置和结束位置

 

【5】开启线程去执行下载

                通过UrlConnection下载部分资源。
                注意：
                 1.需要Range头，key：Range   value：bytes:0-499 
                        urlconnection.setRequestPropety("Range","bytes:0-499")
                 2.需要设置每个线程在本地文件的保存的开始位置
                        RandomAccessFile randomfile =new RandomAccessFile(File file,String mode)
                        randomfile.seek(int startPostion);//本次线程下载保存的开始位置。

    public static class DownloadThread  extends Thread{


        private int threadId;
        private int startIndex;
        private int endIndex;
        private int lastPostion;
        public DownloadThread(int threadId,int startIndex,int endIndex){
            this.threadId = threadId;
            this.startIndex = startIndex;
            this.endIndex = endIndex;
        }

        @Override
        public void run() {
                
            //分段请求网络连接，分段保存文件到本地
            try{
                URL url = new URL(path);
                HttpURLConnection openConnection = (HttpURLConnection) url.openConnection();
                openConnection.setRequestMethod("GET");
                openConnection.setConnectTimeout(10*1000);
                    
                System.out.println("理论上下载：  线程："+threadId+"，开始位置："+startIndex+";结束位置:"+endIndex);
                
                        
                    lastPostion = startIndex;
                    //设置分段下载的头信息。  Range:做分段数据请求用的。
                    openConnection.setRequestProperty("Range", "bytes:"+lastPostion+"-"+endIndex);//bytes:0-500:请求服务器资源中0-500之间的字节信息  501-1000:
                    System.out.println("实际下载：  线程："+threadId+"，开始位置："+lastPostion+";结束位置:"+endIndex);

                if(openConnection.getResponseCode() == 206){//200：请求全部资源成功， 206代表部分资源请求成功
                    InputStream inputStream = openConnection.getInputStream();
                    //请求成功将流写入本地文件中，已经创建的占位那个文件中
                    
                    RandomAccessFile randomAccessFile = new RandomAccessFile(new File(getFileName(path)), "rw");
                    randomAccessFile.seek(lastPostion);//设置随机文件从哪个位置开始写。
                    //将流中的数据写入文件
                    byte[] buffer = new byte[1024];
                    int length = -1;
                    int total = 0;//记录本次线程下载的总大小
                    
                    while((length= inputStream.read(buffer)) !=-1){
                        randomAccessFile.write(buffer, 0, length);
                        //创建随机文件保存当前线程下载的位置
                        File file = new File(threadId+".txt");
                        RandomAccessFile accessfile = new RandomAccessFile(file, "rwd");
                        accessfile.write(String.valueOf(currentThreadPostion).getBytes());
                        accessfile.close();
    
                    }
                    //关闭相关的流信息
                    inputStream.close();
                    randomAccessFile.close();
                    
                    System.out.println("线程："+threadId+"，下载完毕");
                                        
                    //当所有线程下载结束，删除存放下载位置的文件。
                    synchronized (DownloadThread.class) {
                        runningTrheadCount = runningTrheadCount -1;//标志着一个线程下载结束。
                        if(runningTrheadCount == 0 ){
                            System.out.println("所有线程下载完成");
                            for(int i =0 ;i< threadCount;i++){
                                File file = new File(i+".txt");
                                System.out.println(file.getAbsolutePath());
                                file.delete();
                            }
                        }            
                    }
                            
                }    

            }catch (Exception e) {
                e.printStackTrace();
            }
            super.run();
        }

    }
}

【6】断点续传的功能：

【6.1】断点位置的保存

【6.2】断点信息在下次开始下载时读取

【关键】计算好每次开始断点下载的位置与下载开始下载的位置要衔接好；

【7】注意-每次下载完成之后需要删除原来的显示的进度的文件

【8】源码

package com.itheima.muchthreaddown;

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

public class MuchThreadDown {

    private static int threadCount = 3;// 开启3个线程
    private static int blockSize = 0;// 每个线程下载的大小
    private static int runningTrheadCount = 0;// 当前运行的线程数
    private static String path = "http://192.168.13.83:8080/itheima74/feiq.exe";

    /**
     * @param args
     */
    public static void main(String[] args) {

        try {
            // 1.请求url地址获取服务端资源的大小
            URL url = new URL(path);
            HttpURLConnection openConnection = (HttpURLConnection) url
                    .openConnection();
            openConnection.setRequestMethod("GET");
            openConnection.setConnectTimeout(10 * 1000);

            int code = openConnection.getResponseCode();
            if (code == 200) {
                // 获取资源的大小
                int filelength = openConnection.getContentLength();
                // 2.在本地创建一个与服务端资源同样大小的一个文件（占位）
                RandomAccessFile randomAccessFile = new RandomAccessFile(
                        new File(getFileName(path)), "rw");
                randomAccessFile.setLength(filelength);// 设置随机访问文件的大小

                // 3.要分配每个线程下载文件的开始位置和结束位置。
                blockSize = filelength / threadCount;// 计算出每个线程理论下载大小
                for (int threadId = 0; threadId < threadCount; threadId++) {
                    int startIndex = threadId * blockSize;// 计算每个线程下载的开始位置
                    int endIndex = (threadId + 1) * blockSize - 1;// 计算每个线程下载的结束位置
                    // 如果是最后一个线程，结束位置需要单独计算
                    if (threadId == threadCount - 1) {
                        endIndex = filelength - 1;
                    }

                    // 4.开启线程去执行下载
                    new DownloadThread(threadId, startIndex, endIndex).start();

                }

            }

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

    }

    public static class DownloadThread extends Thread {

        private int threadId;
        private int startIndex;
        private int endIndex;
        private int lastPostion;

        public DownloadThread(int threadId, int startIndex, int endIndex) {
            this.threadId = threadId;
            this.startIndex = startIndex;
            this.endIndex = endIndex;
        }

        @Override
        public void run() {

            synchronized (DownloadThread.class) {

                runningTrheadCount = runningTrheadCount + 1;// 开启一线程，线程数加1
            }

            // 分段请求网络连接，分段保存文件到本地
            try {
                URL url = new URL(path);
                HttpURLConnection openConnection = (HttpURLConnection) url
                        .openConnection();
                openConnection.setRequestMethod("GET");
                openConnection.setConnectTimeout(10 * 1000);

                System.out.println("理论上下载：  线程：" + threadId + "，开始位置："
                        + startIndex + ";结束位置:" + endIndex);

                // 读取上次下载结束的位置,本次从这个位置开始直接下载。
                File file2 = new File(threadId + ".txt");
                if (file2.exists()) {
                    BufferedReader bufferedReader = new BufferedReader(
                            new InputStreamReader(new FileInputStream(file2)));
                    String lastPostion_str = bufferedReader.readLine();
                    lastPostion = Integer.parseInt(lastPostion_str);// 读取文件获取上次下载的位置

                    // 设置分段下载的头信息。 Range:做分段数据请求用的。
                    openConnection.setRequestProperty("Range", "bytes:"
                            + lastPostion + "-" + endIndex);// bytes:0-500:请求服务器资源中0-500之间的字节信息
                                                            // 501-1000:
                    System.out.println("实际下载：  线程：" + threadId + "，开始位置："
                            + lastPostion + ";结束位置:" + endIndex);
                    bufferedReader.close();
                } else {

                    lastPostion = startIndex;
                    // 设置分段下载的头信息。 Range:做分段数据请求用的。
                    openConnection.setRequestProperty("Range", "bytes:"
                            + lastPostion + "-" + endIndex);// bytes:0-500:请求服务器资源中0-500之间的字节信息
                                                            // 501-1000:
                    System.out.println("实际下载：  线程：" + threadId + "，开始位置："
                            + lastPostion + ";结束位置:" + endIndex);
                }

                if (openConnection.getResponseCode() == 206) {// 200：请求全部资源成功，
                                                                // 206代表部分资源请求成功
                    InputStream inputStream = openConnection.getInputStream();
                    // 请求成功将流写入本地文件中，已经创建的占位那个文件中

                    RandomAccessFile randomAccessFile = new RandomAccessFile(
                            new File(getFileName(path)), "rw");
                    randomAccessFile.seek(lastPostion);// 设置随机文件从哪个位置开始写。
                    // 将流中的数据写入文件
                    byte[] buffer = new byte[1024];
                    int length = -1;
                    int total = 0;// 记录本次线程下载的总大小

                    while ((length = inputStream.read(buffer)) != -1) {
                        randomAccessFile.write(buffer, 0, length);

                        total = total + length;
                        // 去保存当前线程下载的位置，保存到文件中
                        int currentThreadPostion = lastPostion + total;// 计算出当前线程本次下载的位置
                        // 创建随机文件保存当前线程下载的位置
                        File file = new File(threadId + ".txt");
                        RandomAccessFile accessfile = new RandomAccessFile(
                                file, "rwd");
                        accessfile.write(String.valueOf(currentThreadPostion)
                                .getBytes());
                        accessfile.close();

                    }
                    // 关闭相关的流信息
                    inputStream.close();
                    randomAccessFile.close();

                    System.out.println("线程：" + threadId + "，下载完毕");

                    // 当所有线程下载结束，删除存放下载位置的文件。
                    synchronized (DownloadThread.class) {
                        runningTrheadCount = runningTrheadCount - 1;// 标志着一个线程下载结束。
                        if (runningTrheadCount == 0) {
                            System.out.println("所有线程下载完成");
                            for (int i = 0; i < threadCount; i++) {
                                File file = new File(i + ".txt");
                                System.out.println(file.getAbsolutePath());
                                file.delete();
                            }
                        }

                    }

                }

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

            super.run();
        }

    }

    public static String getFileName(String url) {//通过找到最后一个斜杠的位置，然后提取出文件的名称；

        return url.substring(url.lastIndexOf("/"));

    }

}

 【9】注意事项：

   (1)在下次开始下载时候的位置应该从上次记录下载的位置开始下载：应该是lastPostion,不是startPostion;

      randomAccessFile.seek(lastPostion);// 设置随机文件从哪个位置开始写。

   (2)在文件下载结束之后需要将保存位置的文件删除，在删除前应该关闭文件流，否则文件无法删除；

bufferedReader.close();

 

   (3) 为了使程序更通用，写了 专门的提取文件名称的方法，从url地址中提取

 RandomAccessFile randomAccessFile = new RandomAccessFile(new File(getFileName(path)), "rw");
---------------------------------------------------
4  public static String getFileName(String url)//通过找到最后一个斜杠的位置，然后提取出文件的名称；

(4)在线程个数读取的时候需要注意锁，多个线程同时读取数据或者更改数据容易出现数据不准确

 【10】完整源码下载地址：http://pan.baidu.com/s/1jIKho8I