JAVA写的多线程下载程序，并具有断点续传功能

前面写了单线程下载、断点续传、文件分隔与合并三个程序（具体可以参见我前面的程序），在这个程序的基础之上，我完成了多线程下载程序，并具备断点续传功能。

该程序具有5个文件：Main.java（主文件）、FileCombination.java（临时文件合并）、GetFileThread.java（网络文件获取）、MultiThreadGetFile.java（多线程下载调度程序）、PoliceThread.java（监视线程，确定所有的文件块都完成，并调用文件合并程序）。文件详细如下：

Main.java:

package MultiThread;
/**
* 程序主文件
*/
public class Main
{
String urlFile;//网络文件地址
int threadNum;//要启动下载的线程数
String localFileAddress;//要保存的本地地址，请保重该处没有名为"tmp"的文件夹
public Main()
{
/**
* 下面的由使用者自己设为定
*/
urlFile="http://www.netbox.cn/download/nbsetup.EXE";
threadNum=9;//要同时下载的线程数
localFileAddress="d:\\multiDownTest\\";
}
private void start()
{
Thread thread=new Thread(new MultiThreadGetFile(urlFile,threadNum,localFileAddress));
thread.start();
}
public static void main(String[] args)
{
Main main = new Main();
main.start();
}
}

FileCombination.java:

package MultiThread;
/**
* 合并文件：合并由拆分文件拆分的文件
* 要求将拆分文件放到一个文件夹中
* 主要利用随机文件读取和文件输入输出流
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.RandomAccessFile;

import java.util.Arrays;
import java.util.StringTokenizer;

public class FileCombination extends Thread
{
String srcDirectory=null;//拆分文件存放的目录
String trueDirectory;//结果文件存放目录
String[] separatedFiles;//存放所有拆分文件名
String[][] separatedFilesAndSize;//存放所有拆分文件名及分件大小
int FileNum=0;//确定文件个数
String fileRealName="";//据拆分文件名确定现在原文件名
public FileCombination(String trueDirectory,String srcDirectory)
{
this.srcDirectory=srcDirectory;
this.trueDirectory=trueDirectory;
}
/**
*
* @param sFileName 任一一个拆分文件名
* @return 原文件名
*/
private String getRealName(String sFileName)
{
StringTokenizer st=new StringTokenizer(sFileName,".");
return st.nextToken()+"."+st.nextToken();
}
/**
* 取得指定拆分文件模块的文件大小
* @param FileName 拆分的文件名
* @return
*/
private long getFileSize(String FileName)
{
FileName=srcDirectory+"\\"+FileName;
return (new File(FileName).length());
}
/**
* 生成一些属性，做初使化
* @param drictory 拆分文件目录
*/
private void getFileAttribute(String drictory)
{
File file=new File(drictory);
separatedFiles=new String[file.list().length];//依文件数目动态生成一维数组，只有文件名
separatedFiles=file.list();
//依文件数目动态生成二维数组，包括文件名和文件大小
//第一维装文件名，第二维为该文件的字节大小
separatedFilesAndSize=new String[separatedFiles.length][2];
Arrays.sort(separatedFiles);//排序
FileNum=separatedFiles.length;//当前文件夹下面有多少个文件
for(int i=0;i<FileNum;i++)
{
separatedFilesAndSize[i][0]=separatedFiles[i];//文件名
separatedFilesAndSize[i][1]=String.valueOf(getFileSize(separatedFiles[i]));//文件大上
}
fileRealName=getRealName(separatedFiles[FileNum-1]);//取得文件分隔前的原文件名
}
/**
* 合并文件：利用随机文件读写
* @return true为成功合并文件
*/
private boolean CombFile()
{
RandomAccessFile raf=null;
long alreadyWrite=0;
FileInputStream fis=null;
int len=0;
byte[] bt=new byte[1024];
try
{
raf = new RandomAccessFile(trueDirectory+"\\"+fileRealName,"rw");
for(int i=0;i<FileNum;i++)
{
raf.seek(alreadyWrite);
//System.out.println("alreadyWrite:"+alreadyWrite);
fis=new FileInputStream(srcDirectory+"\\"+separatedFilesAndSize[i][0]);
while((len=fis.read(bt))>0)
{
raf.write(bt,0,len);
}
fis.close();
alreadyWrite=alreadyWrite+Long.parseLong(separatedFilesAndSize[i][1]);
}
raf.close();
}
catch (Exception e)
{
e.printStackTrace();
try
{
if(raf!=null)
raf.close();
if(fis!=null)
fis.close();
}
catch (IOException f)
{
f.printStackTrace();
}
return false;
}
return true;
}
public void deleteTmp()
{
for(int i=0;i<FileNum;i++)
{
File file=new File(srcDirectory+"\\"+separatedFilesAndSize[i][0]);
file.delete();
}
File file1=new File(srcDirectory);
file1.delete();
}
public void run()
{
getFileAttribute(srcDirectory);
CombFile();
deleteTmp();
}
}
GetFileThread.java:

package MultiThread;
/**
* 下载线程
* 原理：
* 根据传入的下载开始点以及文件下载结束点，利用HttpURLConnection的RANGE属性，
* 从网络文件开始下载，并结合判断是否下载的文件大小已经等于（文件下载结束点-下载开始点）， *
* 这里结合断点续传原理，可以更快、更有效的下载文件
*/
import java.io.BufferedInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.net.*;

public class GetFileThread extends Thread
{
long startPos,endPos;//传入的文件下载开始、结束点
String currentFileThreadName;//要带上完整的路径
String urlFile;//网络文件地址
int currentThread;//当前是那个线程，这主要是用于下载完成后将对应的检测标志设为true，表示下载完成
/**
*
* @param urlFile 网络文件地址
* @param startPos 网络开始下载点
* @param endPos 网络文件结点
* @param currentFileThreadName 当前线程的完程路径及名字
* @param currentThread 当前是第几个线程
*/
public GetFileThread(String urlFile,long startPos,long endPos,String currentFileThreadName,int currentThread)
{
this.startPos=startPos;
this.endPos=endPos;
this.currentFileThreadName=currentFileThreadName;
this.urlFile=urlFile;
this.currentThread=currentThread;
}
private boolean FileExist(String pathAndFile)
{
File file = new File(pathAndFile);
if (file.exists())
return true;
else
return false;
}

private long FileSize(String pathAndFile)
{
long fileSize=0;
File filet = new File(pathAndFile);
fileSize=filet.length();
return fileSize;
}

private void FileRename(String fName, String nName)
{
File file = new File(fName);
file.renameTo(new File(nName));
file.delete();
}

public void run()
{
URL url = null;
HttpURLConnection httpURLConnection = null;
DataOutputStream dos = null;
BufferedInputStream bis = null;
FileOutputStream fos = null;
String localFile = currentFileThreadName; //文件保存的地方及文件名，具体情况可以改
String localFile_tp = localFile + ".tp"; //未下载完文件加.tp扩展名，以便于区别
long fileSize = 0;//在断点续传中，用于取得当前文件已经下载的大小
int len = 0;
byte[] bt = new byte[1024];//缓冲区
//byte[] buffer=new byte[50*1024];
RandomAccessFile raFile = null;
long TotalSize = 0; //当前块要下载的文件总大小
try
{
url = new URL(urlFile);
httpURLConnection = (HttpURLConnection) url.openConnection();
//TotalSize = Long.parseLong(urlc.getHeaderField("Content-Length"));//取得网络文件大小
TotalSize=endPos-startPos;//取得要该块文件实际要写的大小
long downSize=0;//已经下载的大小
//确定临时文件是否存在
if (FileExist(localFile_tp)) //采用断点续传，这里的依据是看下载文件是否在本地有.tp有扩展名同名文件
{
System.out.println("文件续传中...");
fileSize=new File(localFile_tp).length();//取得已经下载的大小，以便确定随机写入的位置
downSize=fileSize;//下载大小
fileSize=fileSize+startPos;//取得文件开始写入点
//设置User-Agent
//urlc.setRequestProperty("User-Agent","NetFox");
/**
* httpURLConnection属性的设置一定要在得到输入流之前，否则会报已经连接的错误
*/
//设置断点续传的开始位置
//synchronized(new Object()){
httpURLConnection.setRequestProperty("RANGE", "bytes=" + fileSize + "-");
//urlc.setRequestProperty("RANGE", "bytes="+fileSize);//这样写不行，不能少了这个"-".
//设置接受信息
httpURLConnection.setRequestProperty("Accept",
"image/gif,image/x-xbitmap,application/msword,*/*");
//}
raFile = new RandomAccessFile(localFile_tp, "rw"); //随机方位读取
raFile.seek(downSize); //定位指针到fileSize位置
bis = new BufferedInputStream(httpURLConnection.getInputStream());
while ((len = bis.read(bt)) > 0)
{
if(downSize<(endPos-startPos))
{
downSize=downSize+len;
if(downSize>(endPos-startPos))
{
len=(int)((endPos-startPos)-(downSize-len));
}
raFile.write(bt, 0, len);
}
else
break;
}
//System.out.println("文件续传接收完毕！");
}
else if(!FileExist(localFile))//采用原始下载，但保证该文件没有下载
{
//设置断点续传的开始位置
httpURLConnection.setRequestProperty("RANGE", "bytes=" + startPos + "-");
bis = new BufferedInputStream(httpURLConnection.getInputStream());
fos = new FileOutputStream(localFile_tp); //没有下载完毕就将文件的扩展名命名.tp
dos = new DataOutputStream(fos);
//System.out.println("正在接收文件...");
while ((len = bis.read(bt)) > 0)
{
if(downSize<(endPos-startPos))//确定没有下载完毕
{
downSize=downSize+len;
if(downSize>(endPos-startPos))//如果当前下载的加上要下载的已经超过要求的下载范围
{
len=(int)((endPos-startPos)-(downSize-len));//就只取满足要求的下功部份
}
dos.write(bt, 0, len);//写文件
}
else
break;
}
}
if (bis != null)
bis.close();
if (dos != null)
dos.close();
if (fos != null)
fos.close();
if (raFile != null)
raFile.close();
//System.out.println("localFile_bak:" + FileSize(localFile_bak));
if (FileSize(localFile_tp) == TotalSize) //下载完毕后，将文件重命名
{
FileRename(localFile_tp, localFile);
}
MultiThreadGetFile.checkList[currentThread]=true;
}
catch (Exception e)
{
try
{
if (bis != null)
bis.close();
if (dos != null)
dos.close();
if (fos != null)
fos.close();
if (raFile != null)
raFile.close();
}
catch (IOException f)
{
f.printStackTrace();
}
e.printStackTrace();
}
}
}
MultiThreadGetFile.java:

package MultiThread;
/**
* 多线程下载调度程序
*/
import java.io.File;

import java.net.HttpURLConnection;
import java.net.URL;
import java.util.StringTokenizer;

public class MultiThreadGetFile extends Thread
{
long startPos=0,endPos=0;
String currentFileThreadName;//要带上完整的路径
String urlFile;//网络文件地址
String urlFileName;//网络文件名
String localFileAddress;//下载文件要存放的地址
int threadNum;//要同时下载的线程数
long[] eachThreadLength;//每个线程要下功的文件分块的大小
long urlFileLength;//网络文件的大小
URL url;
HttpURLConnection httpURLConnection;
public static boolean[] checkList;//检测线程
public MultiThreadGetFile(String urlFile,int threadNum,String localFileAddress)
{
this.urlFile=urlFile;
this.threadNum=threadNum;//要同时下载的线程数
this.localFileAddress=localFileAddress;

}
private void init_getEachThreadLength()//确定每个线程文件最终要写的文件在大小
{
long l;
l=urlFileLength/threadNum;
for(int i=0;i<threadNum;i++)
{
if(i==threadNum-1)//如果是分配最后一个线程了
{
eachThreadLength[i]=urlFileLength-i*l;
}
else
eachThreadLength[i]=l;
}
}
private String GetFileName(String file)
{
StringTokenizer st=new StringTokenizer(file,"/");
while(st.hasMoreTokens())
{
file=st.nextToken();
}
return file;
}
private void init()
{

if(!new File(localFileAddress+"tmp").mkdir())//创建一个临时文件夹
{
System.out.println("创建文件夹失败！");
}
eachThreadLength=new long[threadNum];
try
{
url=new URL(urlFile);
httpURLConnection=(HttpURLConnection)url.openConnection();
urlFileLength=Long.parseLong(httpURLConnection.getHeaderField("Content-Length"));
urlFileName=url.getFile();//取得在服务器上的路径及文件名
urlFileName=GetFileName(urlFileName);//只得文件名
init_getEachThreadLength();
httpURLConnection.disconnect();
checkList=new boolean[threadNum+1];
for(int i=1;i<=threadNum;i++)
{
if(i>1)
startPos=startPos+eachThreadLength[i-2];
endPos=startPos+eachThreadLength[i-1];
currentFileThreadName=localFileAddress+"tmp\\"+urlFileName+".part"+i;
//System.out.println("startPos:"+(startPos));
//System.out.println("endPos:"+(endPos));
//System.out.println("Size:"+(endPos-startPos));
Thread thread=new Thread(new GetFileThread(urlFile,startPos,endPos,currentFileThreadName,i));
thread.start();
checkList[i]=false;//表示该线程开始
}
Thread policeThread=new Thread(new PoliceThread(threadNum,localFileAddress,localFileAddress+"tmp"));
policeThread.start();
}
catch (Exception e)
{
e.printStackTrace();
}
}
public void run()
{
init();
}
}

PoliceThread.java:

package MultiThread;

/**
* 监视线程，检测其它的线程是否已经运行完毕
* 原理：
* 在MultiThreadGetFile里定义一个全局静态boolean数组，在启动每个GetFileThread
* 的时候，就将对应的数组的值设为false，当对应线程完成后就把对应的数组设为true，
* 在当前线程采用不停检测是否所有数组的值都为true，如是那就说明所有的线程已经运行完
* 毕，如果没有就继续检测。
* 等到所有的GetFileThread线程都完成后，那么就调用文件拼合线程，合并下载的文件块并删除
* 临时文件块。
*/
public class PoliceThread
extends Thread
{
int totalThread;
String localFileAddress;
String localFileAddress_tmp;

public PoliceThread(int totalThread, String localFileAddress,
String localFileAddress_tmp)
{
this.totalThread = totalThread;
this.localFileAddress = localFileAddress;
this.localFileAddress_tmp = localFileAddress_tmp;
}

public void run()
{
boolean isRun = true;
int allStop = 0;
while (isRun)
{
allStop=0;
for (int i = 1; i <= totalThread; i++)
{
if (MultiThreadGetFile.checkList[i] == true)
{
allStop++;
}
}
try
{
this.sleep(500);
}
catch (Exception e)
{
e.printStackTrace();
}
if (allStop == totalThread)
isRun = false;
}
Thread thread =
new Thread(new FileCombination(localFileAddress, localFileAddress_tmp));
thread.start();
}
}