本篇博客主要介绍多线程去下载文件，以下载多个apk为例。不管去下在apk，音视频等文件，实现起来都一样。
篇幅有点长，先贴张美女图看看
meinv.jpg
正在下载的效果图
2018-04-25_13_36_47.gif
下载完成效果图
screen.png
小编的下载路径是放在sd卡的绝对路径中，方便验证！
工程目录图
content.png
介绍下每个类是干什么的
DownloadCallback：下载完成回调接口，包含三个方法 void onSuccess(File file)、void onFailure(Exception e)、void onProgress(long progress,long currentLength); DownloadDispatcher：负责创建线程池，连接下载的文件； DownloadRunnable：每个线程的执行对应的任务； DownloadTask：每个apk的下载，这个类需要复用的； OkHttpManager:封装下okhttp，管理okhttp； CircleProgressbar:自定义的圆形进度条；
具体思路：
1、首先自定义一个圆形进度条CircleProgressbar 2、创建线程池，计算每个线程对应的不同的Range 3、每个线程下载完毕之后的回调，若出现了异常怎么处理
OkHttpManager类
public class OkHttpManager {private static final OkHttpManager sOkHttpManager = new OkHttpManager();private OkHttpClient okHttpClient;private OkHttpManager() {
okHttpClient = new OkHttpClient();
}public static OkHttpManager getInstance() { return sOkHttpManager;
}public Call asyncCall(String url) {
Request request = new Request.Builder()
.url(url)
.build(); return okHttpClient.newCall(request);
}public Response syncResponse(String url, long start, long end) throws IOException {
Request request = new Request.Builder()
.url(url) //Range 请求头格式Range: bytes=start-end
.addHeader("Range", "bytes=" + start + "-" + end)
.build(); return okHttpClient.newCall(request).execute();
}
}大家可能会看到这个Range很懵，Range是啥？
什么是Range？
当用户在听一首歌的时候，如果听到一半（网络下载了一半），网络断掉了，用户需要继续听的时候，文件服务器不支持断点的话，则用户需要重新下载这个文件。而Range支持的话，客户端应该记录了之前已经读取的文件范围，网络恢复之后，则向服务器发送读取剩余Range的请求，服务端只需要发送客户端请求的那部分内容，而不用整个 文件发送回客户端，以此节省网络带宽。
例如：
Range: bytes=10- ：第10个字节及最后个字节的数据 。
Range: bytes=40-100 ：第40个字节到第100个字节之间的数据。
注意，这个表示[start,end]，即是包含请求头的start及end字节的，所以，下一个请求，应该是上一个请求的[end+1, nextEnd]
DownloadCallback类
public interface DownloadCallback { /**
* 下载成功
*
* @param file
*/
void onSuccess(File file); /**
* 下载失败
*
* @param e
*/
void onFailure(Exception e); /**
* 下载进度
*
* @param progress
*/
void onProgress(long progress,long currentLength);
}DownloadCallback：下载完成回调接口，包含三个方法 void onSuccess(File file)下载文件成功回调、void onFailure(Exception e)下载文件失败回调、void onProgress(long progress,long currentLength) 下载文件实时更新下圆形进度条。
DownloadDispatcher 类
public class DownloadDispatcher { private static final String TAG = "DownloadDispatcher"; private static volatile DownloadDispatcher sDownloadDispatcher; private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors(); private static final int THREAD_SIZE = Math.max(3, Math.min(CPU_COUNT - 1, 5)); //核心线程数
private static final int CORE_POOL_SIZE = THREAD_SIZE; //线程池
private ExecutorService mExecutorService; //private final Deque<DownloadTask> readyTasks = new ArrayDeque<>();
private final Deque<DownloadTask> runningTasks = new ArrayDeque<>(); //private final Deque<DownloadTask> stopTasks = new ArrayDeque<>();private DownloadDispatcher() {
}public static DownloadDispatcher getInstance() { if (sDownloadDispatcher == null) { synchronized (DownloadDispatcher.class) { if (sDownloadDispatcher == null) {
sDownloadDispatcher = new DownloadDispatcher();
}
}
} return sDownloadDispatcher;
}/**
* 创建线程池
*
* @return mExecutorService
*/public synchronized ExecutorService executorService() { if (mExecutorService == null) {
mExecutorService = new ThreadPoolExecutor(CORE_POOL_SIZE, Integer.MAX_VALUE, 60, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), new ThreadFactory() { @Override
public Thread newThread(@NonNull Runnable r) {
Thread thread = new Thread(r);
thread.setDaemon(false); return thread;
}
});
} return mExecutorService;
}/**
* @param name 文件名
* @param url 下载的地址
* @param callBack 回调接口
*/public void startDownload(final String name, final String url, final DownloadCallback callBack) {
Call call = OkHttpManager.getInstance().asyncCall(url);
call.enqueue(new Callback() { @Override
public void onFailure(@NonNull Call call, @NonNull IOException e) {
callBack.onFailure(e);
} @Override
public void onResponse(@NonNull Call call, @NonNull Response response) { //获取文件的大小
long contentLength = response.body().contentLength();
Log.i(TAG, "contentLength=" + contentLength); if (contentLength <= -1) { return;
}
DownloadTask downloadTask = new DownloadTask(name, url, THREAD_SIZE, contentLength, callBack);
downloadTask.init();
runningTasks.add(downloadTask);
}
});
}/**
* @param downLoadTask 下载任务
*/public void recyclerTask(DownloadTask downLoadTask) {
runningTasks.remove(downLoadTask); //参考OkHttp的Dispatcher()的源码
//readyTasks.}public void stopDownLoad(String url) { //这个停止是不是这个正在下载的}
}DownloadDispatcher这个类主要负责创建线程池，连接下载的文件，如果你要控制下载文件的个数，比如3-5个，可以在这个类控制，比如你最大允许同时下载三个文件，每个文件有五个线程去下载，那么maxRequest只有15个线程，其余的可以放到readyTasks 中，有一个线程下载完毕了可以remove()掉，总结起来说一句话，去仿照okhttp的Dispatcher源码去写，runningTasks、readyTasks、stopTasks。
DownloadTask
public class DownloadTask { private static final String TAG = "DownloadTask"; //文件下载的url
private String url; //文件的名称
private String name; //文件的大小
private long mContentLength; //下载文件的线程的个数
private int mThreadSize; //线程下载成功的个数,变量加个volatile，多线程保证变量可见性
private volatile int mSuccessNumber; //总进度=每个线程的进度的和
private long mTotalProgress; private List<DownloadRunnable> mDownloadRunnables; private DownloadCallback mDownloadCallback;public DownloadTask(String name, String url, int threadSize, long contentLength, DownloadCallback callBack) { this.name = name; this.url = url; this.mThreadSize = threadSize; this.mContentLength = contentLength; this.mDownloadRunnables = new ArrayList<>(); this.mDownloadCallback = callBack;
}public void init() { for (int i = 0; i < mThreadSize; i++) { //初始化的时候，需要读取数据库
//每个线程的下载的大小threadSize
long threadSize = mContentLength / mThreadSize; //开始下载的位置
long start = i * threadSize; //结束下载的位置
long end = start + threadSize - 1; if (i == mThreadSize - 1) {
end = mContentLength - 1;
}
DownloadRunnable downloadRunnable = new DownloadRunnable(name, url, mContentLength, i, start, end, new DownloadCallback() { @Override
public void onFailure(Exception e) { //有一个线程发生异常，下载失败，需要把其它线程停止掉
mDownloadCallback.onFailure(e);
stopDownload();
} @Override
public void onSuccess(File file) {
mSuccessNumber = mSuccessNumber + 1; if (mSuccessNumber == mThreadSize) {
mDownloadCallback.onSuccess(file);
DownloadDispatcher.getInstance().recyclerTask(DownloadTask.this); //如果下载完毕，清除数据库 todo
}
} @Override
public void onProgress(long progress, long currentLength) { //叠加下progress，实时去更新进度条
//这里需要synchronized下
synchronized (DownloadTask.this) {
mTotalProgress = mTotalProgress + progress; //Log.i(TAG, "mTotalProgress==" + mTotalProgress);
mDownloadCallback.onProgress(mTotalProgress, currentLength);
}
}
}); //通过线程池去执行
DownloadDispatcher.getInstance().executorService().execute(downloadRunnable);
mDownloadRunnables.add(downloadRunnable);
}
}/**
* 停止下载
*/public void stopDownload() { for (DownloadRunnable runnable : mDownloadRunnables) {
runnable.stop();
}
}DownloadTask负责每个apk的下载，这个类需要复用的。计算每个线程下载范围的大小，具体的每个变量是啥？注释写的很清楚。注意的是这个变量mSuccessNumber，线程下载成功的个数,变量加个volatile，多线程保证变量可见性。还有的就是叠加下progress的时候mTotalProgress = mTotalProgress + progress，需要synchronized(DownloadTask.this)下，保证这个变量mTotalProgress内存可见，并同步下。
DownloadRunnable类
public class DownloadRunnable implements Runnable { private static final String TAG = "DownloadRunnable"; private static final int STATUS_DOWNLOADING = 1; private static final int STATUS_STOP = 2; //线程的状态
private int mStatus = STATUS_DOWNLOADING; //文件下载的url
private String url; //文件的名称
private String name; //线程id
private int threadId; //每个线程下载开始的位置
private long start; //每个线程下载结束的位置
private long end; //每个线程的下载进度
private long mProgress; //文件的总大小 content-length
private long mCurrentLength; private DownloadCallback downloadCallback;public DownloadRunnable(String name, String url, long currentLength, int threadId, long start, long end, DownloadCallback downloadCallback) { this.name = name; this.url = url; this.mCurrentLength = currentLength; this.threadId = threadId; this.start = start; this.end = end; this.downloadCallback = downloadCallback;
}@Overridepublic void run() {
InputStream inputStream = null;
RandomAccessFile randomAccessFile = null; try {
Response response = OkHttpManager.getInstance().syncResponse(url, start, end);
Log.i(TAG, "fileName=" + name + " 每个线程负责下载文件大小contentLength=" + response.body().contentLength()
+ " 开始位置start=" + start + "结束位置end=" + end + " threadId=" + threadId);
inputStream = response.body().byteStream(); //保存文件的路径
File file = new File(Environment.getExternalStorageDirectory().getAbsolutePath(), name);
randomAccessFile = new RandomAccessFile(file, "rwd"); //seek从哪里开始
randomAccessFile.seek(start); int length; byte[] bytes = new byte[10 * 1024]; while ((length = inputStream.read(bytes)) != -1) { if (mStatus == STATUS_STOP) break; //写入
randomAccessFile.write(bytes, 0, length); //保存下进度，做断点 todo
mProgress = mProgress + length; //实时去更新下进度条，将每次写入的length传出去
downloadCallback.onProgress(length, mCurrentLength);
}
downloadCallback.onSuccess(file);
} catch (IOException e) {
e.printStackTrace();
downloadCallback.onFailure(e);
} finally {
Utils.close(inputStream);
Utils.close(randomAccessFile); //保存到数据库 怎么存？？ todo
}
}public void stop() {
mStatus = STATUS_STOP;
}
}DownloadRunnable负责每个线程的执行对应的任务，使用RandomAccessFile写入文件。最后看一张截图
D2OD.png
哈，看到最后断点下载并没有实现，这个不急，小编还没写，但是实现多线程下载文件整体的思路和代码都已经出来了，至于断点怎么弄，其实具体的思路，在代码注解也已经写出来了，主要是DownloadRunnable 这个类，向数据库保存下文件的下载路径url，文件的大小currentLength，每个线程id，对应的每个线程的start位置和结束位置，以及每个线程的下载进度progress。用户下次进来可以读取数据库的内容，有网的情况下重新发请请求，对应Range: bytes=start-end；