多线程下载 与 断点续传

今天学习了多线程的的下载。向大家分享一下。

首先呢，什么是多线程下载。现在有三个人去同一个服务器里下载 同一个资源。 而服务器的带宽是均分给每一个线程的。那么机智的你当然想下载的更快，所以你开了多个线程来下载。假设服务器的带宽是9M,有三个人下载 每个人开的单线程在执行下载任务的话。当然你和其他两个均分9M带宽，为3M。但这是你开启了3个线程下载，就是当前有5个线程均分服务器的总带宽 而你拥有的速度 就是 你开启的线程数* （服务器总带宽/ 当前下载的总线程数） 这里为3*（9/5） 速度为其他两个的3倍。

基本概念有了，那我们知道什么听起来 高大上的 多线程下载 也就是多开启几个线程下载而已。那开启多个线程 又会 给我们带来哪些问题

总结一下

一：我们得把需要下载的总文件的长度，分配好给对应的线程来负责下载，也就是计算好每个线程对应的下载区间

二：我们每个线程得到的数据流 应该是 对应下载任务区间的流

三：我们每个线程的写入开始位置应该是 对应下载区间的首位置

四：下载文件前 在硬盘上开辟一个等容量的空间，来用储存下载的文件

接下来看一看代码，看一看 这些问题分别在代码的哪些地方得到解决：

public class Mian {
// 线程数量
private static int ThreadCount = 3;
// 路径，该路径是网上一个  android api文档下载路径
public static final String PATH ="http://dl.download.csdn.net/down10/20150115/202d14961bdf45de7dbb9c17efb39496.chm?response-content-disposition=attachment%3Bfilename%3D%22Android%E5%AE%98%E6%96%B9API%E6%96%87%E6%A1%A3%E5%AE%8C%E6%95%B4%E7%89%88.chm%22&OSSAccessKeyId=9q6nvzoJGowBj4q1&Expires=1464750083&Signature=efVjCq9nB8mlj2z0R%2FGrchRZYu8%3D";
//记录下载完成  的线程数量，其目的是为了在所有线程都下载完 将临时文件删除
public static int FinishedThread = 0;
public static void main(String[] args) {
try {
URL url = new URL(PATH);
HttpURLConnection connection = (HttpURLConnection) url
.openConnection();
connection.setRequestMethod("GET");
connection.setConnectTimeout(8000);
connection.setReadTimeout(8000);
System.out.println(connection.getResponseCode()+"!!!!!!!");
if (connection.getResponseCode() == 200) {

int lenght = connection.getContentLength();
System.out.println(lenght/1024+".....");
int size = (int) (lenght / ThreadCount);

// 拿到了文件的长度，在下载前要建造一个大小相等的空文件
File file = new File("view.chm");
RandomAccessFile raf = new RandomAccessFile(file, "rwd");
raf.setLength(lenght);
for (int id = 0; id < ThreadCount; id++) {
// 1.确定每个线程的下载区间
// 2.开启线程 下载
int startIndex = (id * size);
int endIndex = (id + 1) * size - 1;
if (id == ThreadCount - 1) {
endIndex = (int) (lenght - 1);
}
System.out.println("第"+id+"个进程的下载区间为"+startIndex+"----"+endIndex);

DownThreads downThreads = new DownThreads(startIndex, endIndex, PATH, id,ThreadCount);
downThreads.start();

}

}

} catch (MalformedURLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}

上面代码大概可以概括为

1第一遍拿到流 为了得到要下载文件的大小 lenght

2 拿到大小为的是 为所要下载的文件 开辟 同样大小的空间，并且在 for 循环中为每个线程 分配好下载区间（前几个线程分配的大小为lenght/ThreadCound,最后一个线程例外 可能多出来也可能少出来一点，但是endIndex 必然是 lenght-1）

3. 开启了若干个线程来执行下载任务（这里我们定义了三个）

然后 看一下DownThreads 里面的代码

public class DownThreads extends Thread {
private int startIndex;
private int endIndex;
private String path;
private int threadId;
private int TheardCount;

public DownThreads(int startIndex, int endIndex, String path, int threadId,
int ThreadCount) {
super();
this.startIndex = startIndex;
this.endIndex = endIndex;
this.path = path;
this.threadId = threadId;
this.TheardCount = ThreadCount;
}

@Override
public void run() {
// TODO Auto-generated method stub
super.run();
URL url;
try {
//关于断点续传  有三个文件存下当前下载的 长度
File fileProgress = new File(threadId + ".txt");
//上次的进度  从三个临时文件读取
int lastProgress = 0;
//如果文件存在  说明 不是第一次下载 是没下载完的状态   那么这是就要将startIndex 改为文件里记录的地方
if (fileProgress.exists()) {
FileInputStream fis = new FileInputStream(fileProgress);
BufferedReader br = new BufferedReader(new InputStreamReader(
fis));
lastProgress = Integer.parseInt(br.readLine());
//新的起始位置 为原始的起始 位置 + 文件里记录的位置
startIndex += lastProgress;
}
url = new URL(path);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setConnectTimeout(8000);
connection.setReadTimeout(8000);
// 得到对应下载区间的流
connection.setRequestProperty("Range", "bytes=" + startIndex + "-"+ endIndex);
if (connection.getResponseCode() == 206) {
InputStream is = connection.getInputStream();
File file = new File("view.chm");
// 填充空白的文件 生成一个空白有大小的文件   主文件
RandomAccessFile raf = new RandomAccessFile(file, "rwd");
// 从该位置开始写入
raf.seek(startIndex);
byte[] b = new byte[1024];
int len = 0;
//total 每单个线程下载的总量  初始值为文件记录的 位置值  如为第一次下载文件不存在 那么 为lastProgress的初始值 0
int total = lastProgress;
while ((len = is.read(b)) != -1) {
raf.write(b, 0, len);
total = total + len;
RandomAccessFile rafProgress = new RandomAccessFile(
fileProgress, "rwd");
rafProgress.write((total + "").getBytes());
rafProgress.close();
System.out.println("第" + threadId + "下载了" + total);
}
System.out.println("第" + threadId + "个线程" + "下载结束！！！！");
Mian.FinishedThread++;
//将Mian.FinishedThread写入文件EndThreadCountFile
File CountFile = new File("EndThreadCount.txt");
RandomAccessFile rafCount = new RandomAccessFile(CountFile, "rwd");
rafCount.write((Mian.FinishedThread+"").getBytes());;
System.out.println(Mian.FinishedThread + "!!!!!!!!!");
//当文件都全部下完  即每个线程任务都结束了  那么删除这三个文件
/*有以文件用于记录已经完成的线程数  因为单单用一个int 来记录存在逻辑上的bug
当其中两个线程结束了，另一个未结束。这时你暂停下载。那么等下次在断点续传的时候 这个int 值只能加到一（假设有三个线程），永远都删除不掉临时文件
因为数据并没有持久化，用文件来保存就不一样了，但是记得最后将它也删除*/
if (CountFile.exists() && readMyFile(CountFile) == TheardCount ) {
System.out.println("if()" + Mian.FinishedThread
+ "!!!!!!!!!");
for (int i = 0; i < TheardCount; i++) {
File f = new File(i + ".txt");
f.delete();
}
CountFile.delete();
}
raf.close();
is.close();

}

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

private int readMyFile(File file) throws Exception{
FileInputStream fis = new FileInputStream(file);
BufferedReader br = new BufferedReader(new InputStreamReader(fis));
int Count =  Integer.parseInt(br.readLine());
return Count;
}

}

这就每个线程里的逻辑代码：

里面添加了断点续传 功能 说白了 就是将你上次下载到哪里 那个Index 存在对应线程的临时文件中 ，这样再次下载的时候就不用再从一开始下载。最后结束线程的个数 为开启线程的总数 就把这些临时文件删除（说明文件已经下完）。

运行图：




下载到的 API文档



这里是下载过程是中断过一次的，说明断点续传是可以的