1、DownloadManager类
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
public class DownloadManager implements Runnable {
// 保存路径
private String savePath;
// 总的下载线程数
private int threadNum;
// 下载的链接地址
private String urlFile;
// 是否下载开始
private boolean isStarted;
// 用于监视何时合并文件存放Thread的list
private List<DownloadThread> downloadList = new ArrayList<DownloadThread>();
public DownloadManager(String savePath, int threadNum, String urlFile) {
super();
this.savePath = savePath;
this.threadNum = threadNum;
this.urlFile = urlFile;
}
// 最终调用线程下载。本线程中调用分线程。
public void action() {
new Thread(this).start();
}
public void run() {
long t1 = System.currentTimeMillis();
System.out.println(t1);
// 如果没有下载 ， 就开始 ， 并且将已经下载的变量值设为true
if (!isStarted) {
startDownload();
isStarted = true;
}
while (true) {
// 初始化认为所有线程下载完成，逐个检查
boolean finish = true;
// 如果有任何一个没完成，说明下载没完成，不能合并文件
for (DownloadThread thread : downloadList) {
if (!thread.isFinish()) {
finish = false;
break;
}
}
// 全部下载完成才为真
if (finish) {
// 合并文件
mergeFiles();
// 跳出循环 ， 下载结束
break;
}
// 休息一会 ， 减少cpu消耗
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
long t2 = System.currentTimeMillis();
System.out.println(t2);
System.out.println("下载用时：" + (t2 -t1));
}
public void startDownload() {
// 得到每个线程开始值 ， 下载字节数大小
int[][] posAndLength = getPosAndLength();
// 根据下载信息创建每个下载线程，并且启动他们。
for (int i = 0; i < posAndLength.length; i++) {
int pos = posAndLength[i][0];
int length = posAndLength[i][1];
DownloadThread downloadThread = new DownloadThread(i + 1, length,
pos, savePath, urlFile);
new Thread(downloadThread).start();
downloadList.add(downloadThread);
}
}
/**
* 获得文件大小
*
* @return 文件大小
*/
public long getFileLength() {
System.out.println("获得文件大小 start......");
HttpURLConnection conn = null;
long result = 0;
try {
URL url = new URL(urlFile);
conn = (HttpURLConnection) url.openConnection();
// 使用Content-Length头信息获得文件大小
result = Long.parseLong(conn.getHeaderField("Content-Length"));
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (conn != null) {
conn.disconnect();
}
}
System.out.println("获得文件大小 end......" + result);
return result;
}
// 具体细节求出每个线程的开始位置和文件下载大小
public int[][] getPosAndLength() {
int[][] result = new int[threadNum][2];
int fileLength = (int) getFileLength();
int every = fileLength % threadNum == 0 ? fileLength / threadNum
: fileLength / threadNum + 1;
for (int i = 0; i < result.length; i++) {
int length = 0;
if (i != result.length - 1) {
length = every;
} else {
length = fileLength - i * every;
}
result[i][0] = i * every;
result[i][1] = length;
}
return result;
}
// 合并文件
public void mergeFiles() {
System.out.println("合并文件 start......");
OutputStream out = null;
try {
out = new FileOutputStream(savePath);
for (int i = 1; i <= threadNum; i++) {
InputStream in = new FileInputStream(savePath + i);
byte[] bytes = new byte[2048];
int read = 0;
while ((read = in.read(bytes)) != -1) {
out.write(bytes, 0, read);
out.flush();
}
if (in != null) {
in.close();
new File(savePath + i).delete();
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
System.out.println("合并文件 end......");
}
public String getSavePath() {
return savePath;
}
public void setSavePath(String savePath) {
this.savePath = savePath;
}
public int getThreadNum() {
return threadNum;
}
public void setThreadNum(int threadNum) {
this.threadNum = threadNum;
}
public String getUrlFile() {
return urlFile;
}
public void setUrlFile(String urlFile) {
this.urlFile = urlFile;
}
public boolean isStarted() {
return isStarted;
}
public void setStarted(boolean isStarted) {
this.isStarted = isStarted;
}
public List<DownloadThread> getDownloadList() {
return downloadList;
}
public void setDownloadList(List<DownloadThread> downloadList) {
this.downloadList = downloadList;
}
}
2、DownloadThread类
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
public class DownloadThread implements Runnable {
// 当前第几个线程 ， 用于给下载文件起名 file1 file2 file3 ...
private int whichThread;
// 监听单一线程下载是否完成
private boolean isFinish;
// 本线程要下载的文件字节数
private int length;
// 本线程向服务器发送请求时输入流的首位置
private int startPosition;
// 保存的路径
private String savePath;
// 要下载的文件 ， 用于创建连接
private String url;
public void run() {
HttpURLConnection conn = null;
InputStream in = null;
OutputStream out = null;
try {
System.out.println("正在执行的线程：" + whichThread);
URL fileUrl = new URL(url);
// 与服务器创建连接
conn = (HttpURLConnection) fileUrl.openConnection();
// 下载使用get请求
conn.setRequestMethod("GET");
// 告诉服务器 ， 我是火狐 ， 不要不让我下载。
conn.setRequestProperty(
"User-Agent",
"Firefox Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3");
// 这里是设置文件输入流的首位置
conn.setRequestProperty("Range", "bytes=" + startPosition + "-");
// 与服务器创建连接
conn.connect();
// 获得输入流
in = conn.getInputStream();
// 在硬盘上创建file1 , file2 , ...这样的文件 ， 准备往里面写东西
out = new FileOutputStream(savePath + whichThread);
// 用于写入的字节数组
byte[] bytes = new byte[4096];
// 一共下载了多少字节
int count = 0;
// 单次读取的字节数
int read = 0;
while ((read = in.read(bytes)) != -1) {
// 检查一下是不是下载到了本线程需要的长度
if (length - count < bytes.length) {
// 比如说本线程还需要900字节，但是已经读取1000
// 字节，则用要本线程总下载长度减去
// 已经下载的长度
read = length - count;
}
// 将准确的字节写入输出流
out.write(bytes, 0, read);
// 已经下载的字节数加上本次循环字节数
count = count + read;
// 如果下载字节达到本线程所需要字节数，消除循环，
// 停止下载
if (count == length) {
break;
}
}
// 将监视变量设置为true
isFinish = true;
} catch (Exception e) {
e.printStackTrace();
} finally {
// 最后进行输入、输出、连接的关闭
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (conn != null) {
conn.disconnect();
}
}
}
public int getStartPosition() {
return startPosition;
}
public void setStartPosition(int startPosition) {
this.startPosition = startPosition;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public int getWhichThread() {
return whichThread;
}
public void setWhichThread(int whichThread) {
this.whichThread = whichThread;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public String getSavePath() {
return savePath;
}
public void setSavePath(String savePath) {
this.savePath = savePath;
}
public DownloadThread(int whichThread, int length, int startPosition,
String savePath, String url) {
super();
this.whichThread = whichThread;
this.length = length;
this.startPosition = startPosition;
this.savePath = savePath;
this.url = url;
}
public DownloadThread() {
super();
}
public boolean isFinish() {
return isFinish;
}
public void setFinish(boolean isFinish) {
this.isFinish = isFinish;
}
}
3、TestDownload测试类
public class TestDownload {
public static void main(String[] args) {
DownloadManager downloadManager = new DownloadManager("d:/upload/09018417.zip" , 5 , "http://10.1.2.65:8080/cetvossFront/09018417.zip");
downloadManager.action();
}
}
代码已经测试可以运行！
分享到：
相关推荐
Java多线程读大文件 java多线程写文件：多线程往队列中写入数据
刚学完多线程和线程池，以及线程爱好者。 使用场景及目标： 大文件的快速下载，经测试在100M带宽的网络下，下载一个40M的文件，不超过两秒钟，当然还得根据自己电脑的配置来讲。 其他说明： 文件如果特别小，而...
Java多线程文件分片下载实现的示例代码 本文将详细介绍Java多线程文件分片下载的实现示例代码，通过示例代码，大家可以学习和理解多线程文件分片下载的技术难点和解决方案。 多线程下载的技术难点 ---------------...
在Java编程语言中，实现多线程文件传输是一种优化程序性能、提高系统资源...在提供的`java多线程文件传输`压缩包中，可能包含了实现这些概念的示例代码，通过分析和学习，可以更好地理解多线程文件传输的原理和实践。
Java编写的多线程下载程序源码是一种利用Java语言特性实现高效大文件下载的技术。在这一程序中，主要涉及到了Java的多线程处理和网络编程两大核心知识点。 首先，让我们深入理解Java的多线程。Java提供了丰富的多...
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
Java多线程文件下载是一种高效的下载策略，它通过将大文件分割成多个部分，然后创建多个线程分别下载这些部分，来实现并行下载。这种技术可以显著提高下载速度，尤其是在网络条件不稳定或者带宽有限的情况下。下面...
在Java编程中，多线程下载文件是一种优化大文件下载速度和效率的技术。它通过将一个大文件分割成多个小部分，然后同时启动多个线程分别下载这些部分，从而达到加速下载的效果。以下是对这个主题的详细解释： 1. **...
本篇将详细介绍如何使用Java实现基于URL的单个大文件分多线程下载。 首先，我们需要了解Java中的`java.net.URL`类，它代表一个统一资源定位符，是访问互联网资源的入口。通过`URL`对象，我们可以获取到网络资源，...
### Java多线程断点下载文件：关键技术与实现 在当今高速互联网环境下，高效的数据传输技术变得至关重要。Java多线程断点续传文件下载技术就是一种能够显著提高下载速度和稳定性的方法。本文将深入解析Java多线程...
本主题将深入探讨如何在Java多线程环境下实现进度条功能。 首先，理解Java多线程的基本概念至关重要。Java通过Thread类和Runnable接口来支持多线程。创建一个新线程通常有两种方式：继承Thread类并重写run()方法，...
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
Java多线程下载技术主要应用于提高大文件下载的效率，通过将文件分割成多个部分，同时启动多个线程分别下载这些部分，从而实现并行下载，加快下载速度。以下是对这个主题的详细解释： 1. **Java多线程基础**： 在...
通过以上分析可以看出，Java多线程加队列上传文件的实现不仅涉及基础的网络编程和文件操作知识，还需要掌握高级的多线程管理和并发控制技术。这种技术方案适用于需要高效处理大量文件上传请求的场景，比如云存储服务...
【Java多线程简单下载器】是一个初学者的编程作业，虽然代码可能较为混乱，但其核心功能已经实现，即通过多线程技术进行文件的下载。在Java中，多线程是并发处理的重要手段，它允许多个任务在同一时间执行，从而提高...
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个小部分，然后创建多个线程同时下载这些部分，以提高下载速度。这种技术在处理大文件或者网络带宽有限的情况下尤其有用，...
2. **Java多线程实现**： - 实现方式一：继承`Thread`类。创建一个新的类，继承自`Thread`，重写`run()`方法，然后创建该类的实例并调用`start()`方法启动线程。 - 实现方式二：实现`Runnable`接口。创建一个类，...
为了解决这个问题，Java多线程下载利用了操作系统并发处理的能力，将一个大文件分割成多个小部分，每个部分由一个独立的线程负责下载，从而实现断点续传，提高下载速度。 首先，理解Java多线程的基础概念至关重要。...
Java多线程是Java编程中的重要概念，尤其在如今的多核处理器环境下，理解并熟练掌握多线程技术对于提高程序性能和响应速度至关重要。本资料详细讲解了Java多线程的原理，并提供了丰富的实战代码，非常适合Java初学者...