Java基础之多线程断点下载

基本原理：

首先利用URLConnection获取想要下载的文件的长度，然后由URLConnection获取输入流，根据文件的长度以及下载线程的个数，将文件分成固定大小的块，每一块单独启动一个线程读取、写入。通过输入流读取下载文件的信息，然后将读取的信息用RandomAccessFile随机写入到本地文件中。同时，在每个线程中需要用一个临时文件来保存当前已经下载文件的长度，这样的话如果本次下载没有完成，下一次可以在原来已经下载好的基础上继续下载，就不需要重新下载原来已经下过的部分。

代码如下

如果想要多线程下载只需要传入文件下载路径，文件保存路径以及线程的个数，便可以将文件下载至本地。

package com.xqq.mutilthreaddownload;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 多线程下载
* @author xqq
*/
public class MutilThreadDownload extends Thread {

private String downloadPath;
private String savePath;
private int nThread;
private final ExecutorService exec;

public MutilThreadDownload(String downloadPath, String savePath, int nThread) {
this.downloadPath = downloadPath;
this.savePath = savePath;
this.nThread = nThread;
this.exec = Executors.newFixedThreadPool(nThread);
}

@Override
public void run() {
try {
// 连接获取文件信息
URL url = new URL(downloadPath);

HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(5000);
conn.setRequestMethod("GET");

int code = conn.getResponseCode();
if (code == 200) {

int length = conn.getContentLength();// 获取文件长度
System.out.println("文件的总长度为： " + length);

//每个线程所需下载文件的大小
int blockSize = length / nThread;

for (int i = 1; i <= nThread; i++) {

int startIndex = (i - 1) * blockSize;
int endIndex = i * blockSize - 1;

if (i == nThread) {
endIndex = length;
}
//开始下载文件
exec.execute(new Download(startIndex, endIndex, downloadPath, i, savePath));
}
} else {
System.out.println("文件错误......");
}

} catch (MalformedURLException e) {
System.out.println("MalformedURLException");
} catch (IOException e) {
System.out.println("IOException");
}
//当所有线程均下载完成之后，关闭线程池
exec.shutdown();
}
}

根据文件开始和结束位置从输入流中读取文件并利用RandomAccessFile保存至相应位置。

package com.xqq.mutilthreaddownload;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

public class Download implements Runnable{

private int startIndex;
private int endIndex;
private String path;
private static int runningThread = Test.nThread;
private int threadID;
private String savePath;

public Download(int startIndex, int endIndex, String path, int threadID, String savePath) {
this.startIndex = startIndex;
this.endIndex = endIndex;
this.path = path;
this.threadID = threadID;
this.savePath = savePath;
}

public void run() {

try {
File tempFile = new File(savePath + threadID + ".txt");

if(tempFile.exists() && tempFile.length() > 0){
FileInputStream fis = new FileInputStream(tempFile);
byte [] temp = new byte[1024];
int length = fis.read(temp);
String downloadLen = new String(temp, 0, length);
startIndex = Integer.parseInt(downloadLen);
fis.close();
}
System.out.println(Thread.currentThread() + " 下载范围： " + startIndex + " - >" + endIndex);
URL url = new URL(path);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
conn.setConnectTimeout(5000);
conn.setRequestMethod("GET");

int code = conn.getResponseCode();
//获取部分数据，成功返回206
if(code == 206){
RandomAccessFile file = new RandomAccessFile(savePath + "setup.exe", "rwd");
file.seek(startIndex);//定位到文件的位置

InputStream in = conn.getInputStream();

byte [] buffer = new byte[1024 * 2];
int len = 0;
int total = 0;
while((len = in.read(buffer)) != -1){
RandomAccessFile totalFile = new RandomAccessFile(savePath + threadID + ".txt", "rwd");
file.write(buffer, 0, len);
total += len;
totalFile.write((total + startIndex + "").getBytes());
totalFile.close();
}
file.close();
}else{
System.out.println(Thread.currentThread() + " 下载失败");
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
System.out.println(Thread.currentThread() + " 下载完成.....");
runningThread --;
if(runningThread == 0){
for(int i = 1; i <= Test.nThread; i++){
File file = new File(savePath + i + ".txt");
file.delete();
}
}
}
}
}

测试文件

package com.xqq.mutilthreaddownload;

public class Test {
private final static String downloadPath = "http://localhost:8080/123.exe";
private static final String savePath = "c://";
public static final int nThread = 5;

public static void main(String[] args) {
MutilThreadDownload thread = new MutilThreadDownload(downloadPath,savePath,  nThread);
thread.start();
}
}

测试结果：
文件的总长度为： 13087904
Thread[pool-1-thread-2,5,main] 下载范围： 3283180 - >5235159
Thread[pool-1-thread-3,5,main] 下载范围： 5900760 - >7852739
Thread[pool-1-thread-4,5,main] 下载范围： 8518340 - >10470319
Thread[pool-1-thread-5,5,main] 下载范围： 11133872 - >13087904
Thread[pool-1-thread-1,5,main] 下载范围： 665600 - >2617579
Thread[pool-1-thread-4,5,main] 下载完成.....
Thread[pool-1-thread-2,5,main] 下载完成.....
Thread[pool-1-thread-3,5,main] 下载完成.....
Thread[pool-1-thread-5,5,main] 下载完成.....
Thread[pool-1-thread-1,5,main] 下载完成.....

总结：

我今天突然发现，使用了线程池，如果你不调用shutdown()或者shutdownNow()显示的关闭线程池，那么main函数就不会停止，会一直等待线程加入线程池中运行。知道了这个之后，我就顿悟了为什么之前我在Android开发的时候使用了线程池却一直打印线程太多的问题。