android怎么实现多线程断点续传功能

这篇文章主要介绍了android怎么实现多线程断点续传功能，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。

创新互联建站服务项目包括吉县网站建设、吉县网站制作、吉县网页制作以及吉县网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，吉县网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到吉县省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

具体内容如下

布局:

MainActivity :

import android.os.Bundle;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

import butterknife.BindView;
import butterknife.ButterKnife;
import butterknife.OnClick;


public class MainActivity extends AppCompatActivity {
 @BindView(R.id.firstBar)
 ProgressBar firstBar;
 @BindView(R.id.tv_progress)
 TextView tvprogress;
 @BindView(R.id.bt)
 Button bt;
 @BindView(R.id.bt_pause)
 Button btPause;
 @BindView(R.id.bt_start)
 Button btStart;
 //下载地址
 private String loadUrl = "http://mirror.aarnet.edu.au/pub/TED-talks/911Mothers_2010W-480p.mp4";
 //文件缓存路径
 private String filePath = Environment.getExternalStorageDirectory() + "/" + "911Mothers.mp4";
 DownLoadFile downLoadFile;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  ButterKnife.bind(this);
  downLoadFile = new DownLoadFile(this, loadUrl, filePath, 3);
  downLoadFile.setOnDownLoadListener(new DownLoadFile.DownLoadListener() {
   @Override
   public void getProgress(int progress) {
    tvprogress.setText("当前进度 ：" + progress + " %");
    //设置进度条进度
    firstBar.setProgress(progress);
    if (progress==100){
     Toast.makeText(MainActivity.this, "下载完成", Toast.LENGTH_SHORT).show();
    }
   }

   @Override
   public void onComplete() {
    Toast.makeText(MainActivity.this, "下载完成", Toast.LENGTH_SHORT).show();
   }

   @Override
   public void onFailure() {
    Toast.makeText(MainActivity.this, "下载失败", Toast.LENGTH_SHORT).show();
   }
  });



 }

 /*
 * 点击事件
 * */
 @OnClick({R.id.bt, R.id.bt_pause, R.id.bt_start})
 public void onViewClicked(View view) {
  switch (view.getId()) {
   case R.id.bt:
    downLoadFile.downLoad();
    break;
   case R.id.bt_pause:
    downLoadFile.onPause();
    break;
   case R.id.bt_start:
    downLoadFile.onStart();
    break;
  }
 }

 @Override
 protected void onDestroy() {
  downLoadFile.onDestroy();
  super.onDestroy();
 }
}

DownLoadFile:

import android.content.Context;
import android.content.SharedPreferences;
import android.os.Handler;
import android.os.Message;

import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;

public class DownLoadFile {
 private static final String SP_NAME = "download_file";
 private static final String CURR_LENGTH = "curr_length";
 private static final int DEFAULT_THREAD_COUNT = 4;//默认下载线程数

 //以下为线程状态
 private static final String DOWNLOAD_INIT = "1"; //初始化
 private static final String DOWNLOAD_ING = "2";  //正在下载
 private static final String DOWNLOAD_PAUSE = "3"; //暂停
 private Context mContext;
 private String loadUrl;//网络获取的url
 private String filePath;//下载到本地的path
 private int threadCount = DEFAULT_THREAD_COUNT;//下载线程数
 private int fileLength;//文件总大小
 //使用volatile防止多线程不安全
 private volatile int currLength;//当前总共下载的大小
 private volatile int runningThreadCount;//正在运行的线程数
 private Thread[] mThreads;
 private String stateDownload = DOWNLOAD_INIT;//当前线程状态

 //下载进度监听
 private DownLoadListener mDownLoadListener;

 public void setOnDownLoadListener(DownLoadListener mDownLoadListener) {
  this.mDownLoadListener = mDownLoadListener;
 }

 //定义一个下载监听的接口
 public interface DownLoadListener {
  //返回当前下载进度的百分比
  void getProgress(int progress);
  //下载完成
  void onComplete();
  //下载失败
  void onFailure();
 }

 /*
 * 四种有参构造
 * */
 public DownLoadFile(Context mContext, String loadUrl, String filePath) {
  this(mContext, loadUrl, filePath, DEFAULT_THREAD_COUNT, null);
 }

 public DownLoadFile(Context mContext, String loadUrl, String filePath, DownLoadListener mDownLoadListener) {
  this(mContext, loadUrl, filePath, DEFAULT_THREAD_COUNT, mDownLoadListener);
 }

 public DownLoadFile(Context mContext, String loadUrl, String filePath, int threadCount) {
  this(mContext, loadUrl, filePath, threadCount, null);
 }

 public DownLoadFile(Context mContext, String loadUrl, String filePath, int threadCount, DownLoadListener mDownLoadListener) {
  this.mContext = mContext;
  this.loadUrl = loadUrl;
  this.filePath = filePath;
  this.threadCount = threadCount;
  runningThreadCount = 0;
  this.mDownLoadListener = mDownLoadListener;
 }

 /**
  * 开始下载
  */
 protected void downLoad() {
  //在线程中运行，防止anr
  new Thread(new Runnable() {
   @Override
   public void run() {
    try {
     //初始化数据
     if (mThreads == null)
      mThreads = new Thread[threadCount];

     //建立连接请求
     URL url = new URL(loadUrl);
     HttpURLConnection conn = (HttpURLConnection) url.openConnection();
     conn.setConnectTimeout(5000);
     conn.setRequestMethod("GET");
     int code = conn.getResponseCode();//获取返回码
     if (code == 200) {//请求成功,根据文件大小开始分多线程下载
      fileLength = conn.getContentLength();
      //根据文件大小，先创建一个空文件
      //“r“——以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。
      //“rw“——打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。
      //“rws“—— 打开以便读取和写入，对于 “rw”，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。
      //“rwd“——打开以便读取和写入，对于 “rw”，还要求对文件内容的每个更新都同步写入到底层存储设备。
      RandomAccessFile raf = new RandomAccessFile(filePath, "rwd");
      raf.setLength(fileLength);
      raf.close();
      //计算各个线程下载的数据段
      int blockLength = fileLength / threadCount;

      SharedPreferences sp = mContext.getSharedPreferences(SP_NAME, Context.MODE_PRIVATE);
      //获取上次取消下载的进度，若没有则返回0
      currLength = sp.getInt(CURR_LENGTH, 0);
      for (int i = 0; i < threadCount; i++) {
       //开始位置，获取上次取消下载的进度，默认返回i*blockLength,即第i个线程开始下载的位置
       int startPosition = sp.getInt(SP_NAME + (i + 1), i * blockLength);
       //结束位置，-1是为了防止上一个线程和下一个线程重复下载衔接处数据
       int endPosition = (i + 1) * blockLength - 1;
       //将最后一个线程结束位置扩大，防止文件下载不完全，大了不影响，小了文件失效
       if ((i + 1) == threadCount)
        endPosition = endPosition * 2;

       mThreads[i] = new DownThread(i + 1, startPosition, endPosition);
       mThreads[i].start();
      }
     } else {
      handler.sendEmptyMessage(FAILURE);
     }
    } catch (Exception e) {
     e.printStackTrace();
     handler.sendEmptyMessage(FAILURE);
    }
   }
  }).start();
 }

 /**
  * 取消下载
  */
 protected void cancel() {
  if (mThreads != null) {
   //若线程处于等待状态，则while循环处于阻塞状态，无法跳出循环，必须先唤醒线程，才能执行取消任务
   if (stateDownload.equals(DOWNLOAD_PAUSE))
    onStart();
   for (Thread dt : mThreads) {
    ((DownThread) dt).cancel();
   }
  }
 }

 /**
  * 暂停下载
  */
 protected void onPause() {
  if (mThreads != null)
   stateDownload = DOWNLOAD_PAUSE;
 }

 /**
  * 继续下载
  */
 protected void onStart() {
  if (mThreads != null)
   synchronized (DOWNLOAD_PAUSE) {
    stateDownload = DOWNLOAD_ING;
    DOWNLOAD_PAUSE.notifyAll();
   }
 }

 protected void onDestroy() {
  if (mThreads != null)
   mThreads = null;
 }

 private class DownThread extends Thread {

  private boolean isGoOn = true;//是否继续下载
  private int threadId;
  private int startPosition;//开始下载点
  private int endPosition;//结束下载点
  private int currPosition;//当前线程的下载进度

  private DownThread(int threadId, int startPosition, int endPosition) {
   this.threadId = threadId;
   this.startPosition = startPosition;
   currPosition = startPosition;
   this.endPosition = endPosition;
   runningThreadCount++;
  }

  @Override
  public void run() {
   SharedPreferences sp = mContext.getSharedPreferences(SP_NAME, Context.MODE_PRIVATE);
   try {
    URL url = new URL(loadUrl);
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.setRequestMethod("GET");
    conn.setRequestProperty("Range", "bytes=" + startPosition + "-" + endPosition);
    conn.setConnectTimeout(5000);
    //若请求头加上Range这个参数，则返回状态码为206，而不是200
    if (conn.getResponseCode() == 206) {
     InputStream is = conn.getInputStream();
     RandomAccessFile raf = new RandomAccessFile(filePath, "rwd");
     raf.seek(startPosition);//跳到指定位置开始写数据
     int len;
     byte[] buffer = new byte[1024];
     while ((len = is.read(buffer)) != -1) {
      //是否继续下载
      if (!isGoOn)
       break;
      //回调当前进度
      if (mDownLoadListener != null) {
       currLength += len;
       int progress = (int) ((float) currLength / (float) fileLength * 100);
       handler.sendEmptyMessage(progress);
      }

      raf.write(buffer, 0, len);
      //写完后将当前指针后移，为取消下载时保存当前进度做准备
      currPosition += len;
      synchronized (DOWNLOAD_PAUSE) {
       if (stateDownload.equals(DOWNLOAD_PAUSE)) {
        DOWNLOAD_PAUSE.wait();
       }
      }
     }
     is.close();
     raf.close();
     //线程计数器-1
     runningThreadCount--;
     //若取消下载，则直接返回
     if (!isGoOn) {
      //此处采用SharedPreferences保存每个线程的当前进度，和三个线程的总下载进度
      if (currPosition < endPosition) {
       sp.edit().putInt(SP_NAME + threadId, currPosition).apply();
       sp.edit().putInt(CURR_LENGTH, currLength).apply();
      }
      return;
     }
     if (runningThreadCount == 0) {
      sp.edit().clear().apply();
      handler.sendEmptyMessage(SUCCESS);
      handler.sendEmptyMessage(100);
      mThreads = null;
     }
    } else {
     sp.edit().clear().apply();
     handler.sendEmptyMessage(FAILURE);
    }
   } catch (Exception e) {
    sp.edit().clear().apply();
    e.printStackTrace();
    handler.sendEmptyMessage(FAILURE);
   }
  }

  public void cancel() {
   isGoOn = false;
  }
 }

 //请求成功
 private final int SUCCESS = 0x00000101;
 //请求失败
 private final int FAILURE = 0x00000102;

 private Handler handler = new Handler() {
  @Override
  public void handleMessage(Message msg) {

   if (mDownLoadListener != null) {
    if (msg.what == SUCCESS) {
     mDownLoadListener.onComplete();
    } else if (msg.what == FAILURE) {

     mDownLoadListener.onFailure();
    } else {
     mDownLoadListener.getProgress(msg.what);
    }
   }
  }
 };
}

感谢你能够认真阅读完这篇文章，希望小编分享的“android怎么实现多线程断点续传功能”这篇文章对大家有帮助，同时也希望大家多多支持创新互联，关注创新互联行业资讯频道，更多相关知识等着你来学习!