java线程下载文件_以多线程、断点续传方式下载文件的实现

以多线程、断点续传方式下载文件，经常出现下载下来的文件大小和服务端一致，但是却无法正常打开的现象，搞了很久，贴下我的实现方式，请各位多多指教

思路：

1、将下载文件的处理放在自定义的线程类中，每下载一个文件就新启动一个下载线程。

2、在下载线程中完成对服务端的链接和身份认证，成功后开始下载文件。

3、新建n个子线程，根据下载文件的大小和线程数量得到每个子线程要下载的大小。

4、分别启动子线程，进行分段下载。

5、分段下载完成，合并临时文件。

6、合并文件完成，删除临时文件。

实现：

FTP下载线程类

package com.jfc.ftp.tools;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

import com.jfc.ftp.service.FTPService;

import com.jfc.ftp.util.Constant;

import com.jfc.ftp.util.PropertyUtil;

/**

* 为断点续传下载文件而启动新的线程

* @author SavageGarden

*

*/

public class FTPThread extends Thread{

/**

* 站点URL

*/

private String host;

/**

* 站点端口

*/

private int port;

/**

* 用户

*/

private String user;

/**

* 密码

*/

private String pswd;

/**

* 当前线程的FTP操作接口实现类

*/

private FTPService ftpService;

/**

* 第几个下载项

*/

private int rowIndex;

/**

* 要下载的文件路径

*/

private String filepath;

/**

* 要下载的文件大小

*/

private long filesize;

/**

* 要下载的文件保存路径

*/

private String savepath;

/**

* 标记文件已下载量

*/

public int hadRead = 0;

/**

* 下载线程开始时间

*/

public long startTime = 0;

/**

* 下载线程结束时间

*/

public long endTime = 0;

/**

* 当前下载线程的互斥锁

*/

public Lock ftpThreadLock;

/**

* 当前下载线程的状态

*/

private int status = Constant.THREAD_STATUS_NEW;

public synchronized int getStatus() {

return status;

}

public synchronized void setStatus(int status) {

this.status = status;

}

/**

* 是否已经合并文件

*/

private boolean hadMerger = false;

public synchronized boolean isHadMerger() {

return hadMerger;

}

public synchronized void setHadMerger(boolean hadMerger) {

this.hadMerger = hadMerger;

}

/**

* 当前下载线程的状态

*/

private int completed = 0;

public synchronized int getCompleted() {

return completed;

}

public synchronized void setCompleted(int completed) {

this.completed = completed;

}

/**

* 下载线程个构造方法

* 根据已经取得连接的FTPTools得到连接信息

* 根据参数取得下载信息

* @param rowIndex

* @param filepath

* @param filesize

* @param savepath

*/

public FTPThread(int rowIndex, String filepath, long filesize, String savepath) {

super("FTPThread");

host = FTPTools.host;

port = FTPTools.port;

user = FTPTools.user;

pswd = FTPTools.pswd;

this.rowIndex = rowIndex;

this.filepath = filepath;

this.filesize = filesize;

this.savepath = savepath;

ftpThreadLock = new ReentrantLock();

setStatus(Constant.THREAD_STATUS_RUNNABLE);

start();

}

public FTPThread(int rowIndex, String filepath, long filesize, String savepath, int status) {

super("FTPThread");

host = FTPTools.host;

port = FTPTools.port;

user = FTPTools.user;

pswd = FTPTools.pswd;

this.rowIndex = rowIndex;

this.filepath = filepath;

this.filesize = filesize;

this.savepath = savepath;

ftpThreadLock = new ReentrantLock();

setStatus(status);

start();

}

public void run() {

getFTPService();

getFTPConnect(host, port);

if(doLoginFTP(user, pswd)) {

ResumeBrokenTransferByThread(this, rowIndex, filepath, filesize, savepath);

}

}

/**

* 获取FTPService接口实现类

* 首先从配置文件中找

* 如果没有则加载默认的实现类

* @return

* @throws InstantiationException

* @throws IllegalAccessException

* @throws ClassNotFoundException

*/

public void getFTPService(){

try {

ftpService = (FTPService)Class.forName(PropertyUtil.getProperty("ftp.service.name", FTPService.FTP_SERVICE_NAME)).newInstance();

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* 根据服务器地址、端口获得ftp链接

* @param host

* @param port

* @return

*/

public String getFTPConnect(String host, int port) {

return ftpService.getFTPConnect(host, port);

}

/**

* 执行登录

* @param user

* @param pswd

* @return

*/

public boolean doLoginFTP(String user, String pswd) {

return ftpService.doLoginFTP(user, pswd);

}

/**

* 以断点续传的方式下载文件

* @param rowIndex

* @param filepath

* @param filesize

* @param savepath

*/

public void ResumeBrokenTransfer(int rowIndex, String filepath, int filesize, String savepath) {

ftpService.ResumeBrokenTransfer(rowIndex, filepath, filesize, savepath);

}

/**

* 以多线程、断点续传的方式下载文件

* @param rowIndex

* @param filepath

* @param filesize

* @param savepath

*/

public void ResumeBrokenTransferByThread(FTPThread ftpThread, int rowIndex, String filepath, long filesize, String savepath) {

ftpService.ResumeBrokenTransferByThread(ftpThread, rowIndex, filepath, filesize, savepath);

}

/**

* 在指定文件路径下查找临时文件合并为一个文件

* @param filepath

* @param threadCount

*/

public void mergerTempFile(String filepath, int threadCount) {

System.out.println("开始合并文件");

try {

BufferedOutputStream data_output = new BufferedOutputStream(new FileOutputStream(filepath));

byte[] temp = new byte[Constant.TEMP_BYTE_LENGTH];

for(int i = 0; i < threadCount; i ++) {

File tempFile = new File(filepath + Constant.DOWNLOAD_TEMP_NAME + i);

BufferedInputStream data_input = new BufferedInputStream(new FileInputStream(tempFile));

int read = 0;

int hadRead = 0;

while((read = data_input.read(temp, 0, temp.length)) != -1) {

data_output.write(temp, 0, read);

hadRead += read;

}

data_input.close();

}

data_output.close();

} catch (Exception e) {

e.printStackTrace();

}

setHadMerger(true);

System.out.println("合并文件完成");

deleteTempFile(filepath, threadCount);

}

/**

* 合并文件完成后删除临时文件

* @param filepath

* @param threadCount

*/

public void deleteTempFile(String filepath, int threadCount) {

if(isHadMerger()) {

for(int i = 0; i < threadCount; i ++) {

File tempFile = new File(filepath + Constant.DOWNLOAD_TEMP_NAME + i);

tempFile.delete();

}

}

}

}

FTP接口实现类中的ResumeBrokenTransferByThread方法

/**

* 使用多线程、断点续传方式下载文件

* 首先查找要保存的路径下有无缓存文件(以.wfml为后缀)

* 不存在重新开始下载

* 存在继续

* 重新开始下载

* 读取配置文件要分多少个线程来下载文件

* 按照文件大小、线程数量来分配每个线程要下载的文件大小、文件名

* 开始断点续传下载

* 继续下载

* 开始断点续传下载

* @param rowIndex

* @param filepath

* @param filesize

* @param savepath

*/

public void ResumeBrokenTransferByThread(final FTPThread ftpThread, final int rowIndex, final String filepath, final long filesize, final String savepath) {

final String filename = filepath.substring(filepath.lastIndexOf("/") + 1, filepath.length());

final byte[] temp = new byte[Constant.TEMP_BYTE_LENGTH];

//得到要创建的线程数量

final int threadCount = Integer.parseInt(PropertyUtil.getProperty(Constant.RESUME_THREAD_COUNT_PROPNAME, Constant.RESUME_THREAD_COUNT_DEFAULT));

final String[] downloadSizeArray = SystemTools.getDownloadSizeArray(filesize, threadCount);

for(int i = 0; i < threadCount; i ++) {

File temp_file = new File(savepath + File.separator + filename + Constant.DOWNLOAD_TEMP_NAME + i);

System.out.println("文件" + i + "大小为：" + temp_file.length());

ftpThread.hadRead += temp_file.length();

}

System.out.println("ftpThread.hadRead : " + ftpThread.hadRead);

for(int i = 0; i < threadCount; i ++) {

final int index = i;

Thread resumeThread = new Thread(){

//当前线程的缓存文件

File tempFile = new File(savepath + File.separator + filename + Constant.DOWNLOAD_TEMP_NAME + index);

public void run() {

SocketFTPService socketFTPService = new SocketFTPService();

socketFTPService.getFTPConnect(host, port);

if(socketFTPService.doLoginFTP(user, pswd)) {

try {

int read = 0;

int hadRead = 0;

//当前线程要下载的文件大小

String downsize = downloadSizeArray[index].split(":")[1];

//当前线程要下载的文件起始点

String skipsize = downloadSizeArray[index].split(":")[0];

//将hadRead(已读文件大小)置为缓存文件的大小

hadRead = (int)tempFile.length();

//设定文件指针(下载位置)

//socketFTPService.doFTPCommand("REST " + (Integer.parseInt(skipsize) + temp_file.length()));

//readRespond();

socketFTPService.dataSocket = socketFTPService.getDataSocket();

socketFTPService.doFTPCommand("RETR " + filepath);

BufferedInputStream data_input = new BufferedInputStream(socketFTPService.dataSocket.getInputStream());

RandomAccessFile raf = new RandomAccessFile(tempFile, "rw");

//跳过当前线程要下载的文件起始点和缓存文件大小之和

data_input.skip(Integer.parseInt(skipsize) + hadRead);

raf.seek(hadRead);

System.out.println("线程" + index + "已下载 " + hadRead);

if(ftpThread.startTime == 0) {

ftpThread.startTime = System.currentTimeMillis();

}

SystemTools.addObserver();

while(hadRead < Integer.parseInt(downsize)) {

if(ftpThread.getStatus() == Constant.THREAD_STATUS_RUNNABLE) {

while((read = data_input.read(temp, 0, temp.length)) != -1) {

int temp_hadRead = hadRead;

if((temp_hadRead += read) > Integer.parseInt(downsize)) {

read = Integer.parseInt(downsize) - hadRead;

}

raf.write(temp, 0, read);

hadRead += read;

ftpThread.ftpThreadLock.lock();

try {

ftpThread.hadRead += read;

} finally {

ftpThread.ftpThreadLock.unlock();

}

SystemTools.getCurrentSpeed(rowIndex, ftpThread.startTime, ftpThread.hadRead);

SystemTools.getPrice(rowIndex, ftpThread.hadRead, filesize);

SwingUtilities.invokeLater(SystemTools.updateProgressBarRunnable);

}

System.out.println("第" + index + "个线程完成下载" + hadRead + ",完成下载" + ftpThread.hadRead);

raf.close();

if(hadRead == tempFile.length()) {

ftpThread.setCompleted(ftpThread.getCompleted() + 1);

System.out.println(ftpThread.getCompleted());

}

if(ftpThread.getCompleted() == threadCount && ftpThread.hadRead == filesize) {

ftpThread.endTime = System.currentTimeMillis();

SystemTools.getFinalSpeed(rowIndex, ftpThread.startTime, ftpThread.endTime, filesize);

ftpThread.mergerTempFile(savepath + File.separator + filename, threadCount);

}

}

}

} catch(Exception e) {

e.printStackTrace();

}

}

}

};

resumeThread.start();

}

}

欢迎拍砖！