Java多线程分段下载

最新推荐文章于 2025-06-11 15:59:04 发布
最新推荐文章于 2025-06-11 15:59:04 发布
阅读量494 收藏 2
点赞数
分类专栏： Java 文章标签： java 多线程
一直以来，想写一个多线程下载的程序。苦于没得时间，前短时间连续阴雨天，打开电脑百无聊奈。
就把这个程序写了出来。现在发出来，供大家参考。

首先，做分段下载，那么我们得分清楚每一块的数据格式。下图是多线程分段下载的示例图。
 

1：分段文件块的类
  1. package com.eibit.javalearning;

  3. import java.io.Serializable;

  5. /**
  6. * Created by Administrator on 2016/4/15.
  7. */
  8. public class BlockBean implements Serializable{
  9.         private static final long serialVersionUID = 1L;
  10.         //最大的下载尝试次数
  11.         public static final int MAX_TRY_COUNT = 10;
  12.         /**
  13.          * 每次尝试下载的次数
  14.          */
  15.         public int tryCount = 1;
  16.     /**
  17.      * 偏移量
  18.      */
  19.     public long offset = 0;
  20.     /**
  21.      * 分配给本线程的下载字节数
  22.      */
  23.     public long length = 0;
  24.     /**
  25.      * 已下载的字节数
  26.      */
  27.     public long downloadedLength = 0;
  28.     /**
  29.      * block的编号
  30.      */
  31.     public  int i;

  33.     public BlockBean(int i, long offset, long length) {
  34.         this.i = i;
  35.         this.offset = offset;
  36.         this.length = length;
  37.         this.downloadedLength = 0;
  38.     }
  39. }
复制代码

2：下载进度监听接口
  1. package com.eibit.javalearning;

  3. public interface DownListener {

  5.         /**
  6.          * 开始下载
  7.          */
  8.         void onStartDownLoad();
  9.         
  10.         /**
  11.          * 下载进度改变
  12.          * @param completeRate 下载进度
  13.          * @param speed 下载速度 KB/S
  14.          */
  15.         void onCompleteRateChanged(int completeRate);
  16.         
  17.         /**
  18.          * 下载完成
  19.          * @param fileName 存储的文件名
  20.          */
  21.         void onDownloadCompleted(String fileName);

  23.         /**
  24.          * 开启多线程下载
  25.          * @param numberThread 线程数量
  26.          */
  27.         void onStartMultiDownLoad(int numberThread);

  29.         /**
  30.          *        当某块下载完成的时候
  31.          *  @param blockNum 块号
  32.          *  @param readBytes 下载完成的字节
  33.          */
  34.         void onBlockCompleted(int blockNum, long readBytes);
  35.         
  36.         /**
  37.          * 下载速度
  38.          * @param speed 下载速度
  39.          */
  40.         void onDownLoadSpeed(long speed);
  41. }
复制代码

3： 多线程下载控制类
  1. package com.eibit.javalearning;

  3. import java.io.BufferedInputStream;
  4. import java.io.File;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.io.RandomAccessFile;
  9. import java.net.HttpURLConnection;
  10. import java.net.MalformedURLException;
  11. import java.net.URL;
  12. import java.util.LinkedList;
  13. import java.util.concurrent.ExecutorService;
  14. import java.util.concurrent.Executors;

  16. import javax.net.ssl.HttpsURLConnection;

  18. /**
  19. * 文件下载管理类
  20. */
  21. public class ThreadPoolMultiDownLoadManager {
  22.         private String path; //资源的原始路径比如说是http://dlsw.baidu.com/sw-search-sp/soft/ea/12585/mysql-5.6.24-win32.1432006610.zip
  23.         private String targetFile; //下载的文件存储的目标地址
  24.         private DownListener downListener; //下载的监听器
  25.     
  26.     private static long blockSize = 1 * 1024 * 1024; //每块的大小，默认是1MB

  28.         //最大线程数量
  29.         private int MAX_THREAD_NUM = 5; //线程池的线程的数量

  31.     private long fileSize; //文件的总大小
  32.         //private long mTotalDownloadedBytes = 0; //总的已下载的字节数
  33.         private long mLastDownloadedTime = 0; //上次的已下载的字节数的时间，为毫秒,主要用于下载速度的
  34.         private int lastDownloadPercent = 0; //上次下载的百分比,主要是用于计算下载的百分比的
  35.         //固定容量大小的线程池
  36.         private ExecutorService executorService;

  38.         private final Object mLock = new Object(); //用于块队列的同步的锁,不能让一块文件被两个线程下载
  39.         //private final Object lock = new Object(); //用于计算下载百分比同步锁
  40.         private LinkedList<BlockBean> mQueue = new LinkedList<BlockBean>(); //块队列
  41.         private int mCompletedBlock = 0; //已完成的块数
  42.         private int blockCount = 0; //总的块数
  43.         private int mCompletedThreadCount = 0; //已完成的线程的数量,用于统计是否下载结束
  44.         private long mDeltaDownLoadedBytes = 0; //单位时间内下载的字节数

  46.         /**
  47.          * 构造器
  48.          * @param path 资源路径
  49.          * @param targetFile 目标文件的存放地址
  50.          * @param downListener 下载监听器
  51.          */
  52.         public ThreadPoolMultiDownLoadManager(String path, String targetFile, DownListener downListener){
  53.                 this.path = path;
  54.                 this.targetFile = targetFile;
  55.                 this.downListener = downListener;
  56.         }
  57.         
  58.         /**
  59.          * 开启多线程下载
  60.          */
  61.         public void multiDownload(){
  62.                 //初始化,进行清零操作
  63.                 lastDownloadPercent = 0;
  64.                 //mTotalDownloadedBytes = 0;
  65.                 mCompletedBlock = 0;
  66.                 mCompletedThreadCount = 0;
  67.                 //初始化线程池
  68.                 executorService = Executors.newFixedThreadPool(MAX_THREAD_NUM);
  69.                 //执行一个任务
  70.                 //executorService.execute(new GetContentThread());
  71.                 new Thread(new GetContentThread()).start(); //不把这个任务放到线程池里面去
  72.         }
  73.         
  74.         /**
  75.          * 获取文件的大小和属性的一个总控线程
  76.          */
  77.         private class GetContentThread implements Runnable {
  78.                 @Override
  79.                 public void run() {
  80.                         //开始下载
  81.                         if(downListener != null) {
  82.                                 downListener.onStartDownLoad();
  83.                         }
  84.                         doDownload(path, targetFile);
  85.                 }
  86.         }
  87.         
  88.         /**
  89.          * 计算文件大小， 并开启线程下载
  90.          * @param path 资源的url地址
  91.          * @param targetFile 资源本地存放路径
  92.          */
  93.         private void doDownload(String path, String targetFile){
  94.                 try {
  95.                         HttpURLConnection httpConnection = (HttpURLConnection) new URL(path).openConnection();
  96.                         //只获取文件的响应报头，而不获取文件的内容,这个响应报头里面就会包含文件大小等信息
  97.                         httpConnection.setRequestMethod("HEAD");
  98.                         httpConnection.connect();

  100.                         int responseCode = httpConnection.getResponseCode();
  101.                         System.out.println("---------------------------------------responseCode=" + responseCode);
  102.                 if(responseCode >= 400){
  103.                     System.out.println("Web服务器响应错误!");
  104.                     return;
  105.                 }
  106.                         httpConnection.disconnect();
  107.                         if(responseCode == HttpsURLConnection.HTTP_OK) { //服务器响应成功
  108.                                 //获取文件的大小
  109.                                 fileSize = httpConnection.getContentLength(); 
  110.                                 if(fileSize <0) { //使用HEAD获取不到文件大小
  111.                                         UnKnownSizeSingleDowloadThread thread = new UnKnownSizeSingleDowloadThread(path, targetFile);
  112.                                         executorService.execute(thread);
  113.                                         executorService.shutdown();
  114.                                 } else { //可以获取到文件的大小
  115.                                         //生成文件
  116.                                         File newFile = new File(targetFile);
  117.                                         //生成一个可以随机存取的文件RandomAccessFile,以读写的方式打开
  118.                                         RandomAccessFile raf = new RandomAccessFile(newFile, "rw");
  119.                                         raf.setLength(fileSize); //设置这个文件大小
  120.                                         raf.close(); //关闭这个文件

  122.                                         blockCount = 0; //块的数量
  123.                                         //计算有多少个块
  124.                                         if(fileSize % blockSize == 0) {
  125.                                                 blockCount = (int) (fileSize / blockSize);
  126.                                         } else {
  127.                                                 blockCount = (int)(fileSize /blockSize) + 1;
  128.                                         }
  129.                                         System.out.println("Block Count = "+ blockCount);
  130.                                         
  131.                                         mLastDownloadedTime = System.currentTimeMillis(); //初始化第一次下载时间为毫秒级
  132.                                         //再小实际上都可以用块进行下载,可以将其判断去掉
  133.                                         if(blockCount <=5 ){ //如果块的数量小于5块，没必要使用多线程进行下载
  134.                                                 SingleDowloadThread singleDowloadThread = new SingleDowloadThread(path, targetFile, fileSize);
  135.                                                 executorService.execute(singleDowloadThread);
  136.                                                 executorService.shutdown(); //关闭线程池
  137.                                         } else  { //如果块的数量大于5块，则开启多线程下载
  138.                                                 //初始化块的队列
  139.                                                 long offset = 0;
  140.                                                 for(int i=0; i< blockCount; i++) {
  141.                                                         //最后的一块需要特殊对待，因为最后一块的大小可能没有blockSize这么大
  142.                                                         if(i == blockCount -1) {
  143.                                                                 BlockBean bean = new BlockBean(i, offset, fileSize-offset);
  144.                                                                 offset += blockSize;
  145.                                                                 mQueue.add(bean);
  146.                                                         } else {
  147.                                                                 BlockBean bean = new BlockBean(i, offset, blockSize);
  148.                                                                 offset += blockSize;
  149.                                                                 mQueue.add(bean);
  150.                                                         }
  151.                                                 }
  152.                                                 //使用线程池进行操作
  153.                                                 for(int i = 0; i< MAX_THREAD_NUM; i++) {
  154.                                                         DownloadTask task = new DownloadTask(path, targetFile);
  155.                                                         executorService.execute(task);
  156.                                                 }
  157.                                                 executorService.shutdown();
  158.                                         }
  159.                                 }
  160.                         }
  161.                 } catch (MalformedURLException e) {
  162.                         e.printStackTrace();
  163.                 } catch (IOException e) {
  164.                         e.printStackTrace();
  165.                 }
  166.         }
  167.     
  168.     /**
  169.      * 负责文件下载的类
  170.      */
  171.     private class DownloadTask implements Runnable {
  172.         private String url = null;
  173.         private String fileName = null;

  175.         protected DownloadTask(String url, String fileName) {
  176.                         this.url = url;
  177.                         this.fileName = fileName;
  178.         }
  179.      
  180.         public void run() {
  181.                         boolean flag = false; //是否还有块没有下载完成
  182.                         while(!flag) {
  183.                                 BlockBean block = null;
  184.                                 //首先去查找还有没有块已完成
  185.                                 synchronized (mLock) {
  186.                                         if(mQueue.size() > 0) {
  187.                                                 //取一块出来
  188.                                                 block = mQueue.remove(); 
  189.                                         }
  190.                                 }
  191.                                 
  192.                                 //测试代码
  193.                                 /*if(block != null) {
  194.                                         System.out.println("block=" + block.i + ", \tThread Number=" + Thread.currentThread().getName());
  195.                                         try {
  196.                                                 Thread.sleep(200);
  197.                                         } catch (InterruptedException e) {
  198.                                                 e.printStackTrace();
  199.                                         }
  200.                                         
  201.                                         if(block.i % 20 == 0) {
  202.                                                 System.out.println("IOException block =" + block.i);
  203.                                                 synchronized (lock) {
  204.                                                         if(block.tryCount++ < BlockBean.MAX_TRY_COUNT) { //如果还没有达到最大的尝试次数，那么就接着继续下载
  205.                                                                 mQueue.add(block); //把这一块重新加到队列里面去
  206.                                                         }
  207.                                                 }
  208.                                         }
  209.                                 } else {
  210.                                         flag = true;
  211.                                 }*/
  212.                                  
  213.                                 if(block != null) { //还有块没有下载完成
  214.                                         long offset = block.offset;
  215.                                         long length = block.length;
  216.                                         int i = block.i;
  217.                                         //long mLastDownloadedTime = System.currentTimeMillis();
  218.                                         //System.out.println("downLoad block i=" + i + " finished");
  219.                                         try {
  220.                                                 HttpURLConnection httpConnection = (HttpURLConnection) new URL(url).openConnection();
  221.                                                 httpConnection.setRequestMethod("GET");
  222.                                                 httpConnection.setRequestProperty("Accept", "image/gif, image/jpeg, image/pjpeg,*/*");
  223.                                                 httpConnection.setRequestProperty("Accept-Language", "zh_CN");
  224.                                                 httpConnection.setRequestProperty("Charset", "UTF-8");
  225.                                                 httpConnection.setRequestProperty("User-Agent", "Mozilla/4.0(compatible; MSIE 7.0; Windows NT 5.2;)");
  226.                                                 httpConnection.setRequestProperty("Connection", "Keep-Alive"); 
  227.                                                 //设置RANGE属性，向服务器请求，其中的某一段数据
  228.                                                 httpConnection.setRequestProperty("RANGE", "bytes=" + offset + "-" + (offset + length - 1));
  229.                                                 httpConnection.setConnectTimeout(15000); //15秒的连接超时
  230.                                                 httpConnection.setReadTimeout(30000);//30秒的读写超时,连接和读写超时跟网络状态有关
  231.                                                 int responseCode = httpConnection.getResponseCode();
  232.                                                 if(responseCode == HttpURLConnection.HTTP_PARTIAL) { //部分内容
  233.                                                         BufferedInputStream bis = new BufferedInputStream(httpConnection.getInputStream());
  234.                                                         byte[] buffer = new byte[1024];
  235.                                                         int readedBytes = 0;
  236.                                                         File newFile = new File(fileName);
  237.                                                         RandomAccessFile raf = new RandomAccessFile(newFile, "rw");
  238.                                                         raf.seek(offset); //跳转到文件的指定位置
  239.                                                         while((readedBytes = bis.read(buffer,0, buffer.length)) != -1) {
  240.                                                                 raf.write(buffer, 0, readedBytes);
  241.                                                                 //currentDownloadBytes += readedBytes;
  242.                                                         }
  243.                                                         raf.close();
  244.                                                         bis.close();
  245.                                                         httpConnection.disconnect();
  246.                                                         mDeltaDownLoadedBytes+= length; //单位时间内下载的字节数增加

  248.                                                         //以下代码已经废弃
  249.                                                         /*synchronized (lock) {
  250.                                                                 mTotalDownloadedBytes += length;
  251.                                                                 //计算现在速度
  252.                                                                 long currentTime = System.currentTimeMillis();
  253.                                                                 //速度是多少KB/s
  254.                                                                 long speed = (long) (length / ((currentTime - mLastDownloadedTime) /1000.0) /1024);
  255.                                                                 mLastDownloadedTime = currentTime; //重新初始化时间
  256.                                                                 
  257.                                                                 //计算下载的百分比
  258.                                                                 int downloadPercent = (int) (mTotalDownloadedBytes * 100 / fileSize);
  259.                                                                 //System.out.println("mTotalDownloadedBytes=" + mTotalDownloadedBytes + ",fileSize=" + fileSize + ",downloadPercent=" + downloadPercent);
  260.                                                                 if(downloadPercent -lastDownloadPercent >= 1) {//百分之百可能不通知
  261.                                                                         //保证每次更新进展值都大于1，避免更新太过于频繁
  262.                                                                         lastDownloadPercent = downloadPercent;
  263.                                                                         if(downListener != null) {
  264.                                                                                 downListener.onCompleteRateChanged(downloadPercent,speed);
  265.                                                                         }
  266.                                                                 }
  267.                                                                 if(downloadPercent == 100) {
  268.                                                                         if(downListener != null) {
  269.                                                                                 downListener.onCompleteRateChanged(downloadPercent, speed);
  270.                                                                         }
  271.                                                                 }
  272.                                                         }*/
  273.                                                         if(downListener != null) {
  274.                                                                 downListener.onBlockCompleted(i, length);
  275.                                                                 synchronized (mLock) {
  276.                                                                         mCompletedBlock++; //已完成的块加1
  277.                                                                         int percent = mCompletedBlock  * 100 / blockCount;
  278.                                                                         downListener.onCompleteRateChanged(percent);
  279.                                                                         long currentTime = System.currentTimeMillis();
  280.                                                                         
  281.                                                                         if((currentTime - mLastDownloadedTime ) /1000 > 1) {//时间差不到1秒不要去计算速度
  282.                                                                                 //速度是多少KB/s
  283.                                                                                 long speed = (long) (mDeltaDownLoadedBytes / ((currentTime - mLastDownloadedTime) /1000.0) /1024);
  284.                                                                                 mDeltaDownLoadedBytes = 0; //清空单位时间内下载的字节数
  285.                                                                                 mLastDownloadedTime = currentTime; //重新初始化时间
  286.                                                                                 downListener.onDownLoadSpeed(speed);
  287.                                                                         }
  288.                                                                 }
  289.                                                         }
  290.                                                 }
  291.                                         } catch (IOException e) {
  292.                                                 e.printStackTrace();
  293.                                                 //如果出现IO异常，则表示这一块的数据没有完整的下载下来
  294.                                                 //那么将进行一次重新下载
  295.                                                 synchronized (mLock) {
  296.                                                         System.out.println("<<<<<<<<<<<<<<<<<<<<<<<<<< IOException blockNumber:" + i + "<<<<<<<<<<<<<<<<<<<<<<<<");
  297.                                                         blockCount++; //出现异常一次，需要下载的块的数量加1
  298.                                                         if(block.tryCount++ < BlockBean.MAX_TRY_COUNT) { //如果还没有达到最大的尝试次数，那么就接着继续下载
  299.                                                                 mQueue.add(block); //把这一块重新加到队列里面去
  300.                                                         }
  301.                                                 }
  302.                                         }
  303.                                 } else {//没有块可供下载，则结束掉当前线程
  304.                                         flag = true;
  305.                                         break;
  306.                                 }
  307.                         }
  308.                         /*if(mTotalDownloadedBytes >= totalLength && downListener != null) { //下载结束
  309.                                 downListener.onDownloadCompleted(targetFile);
  310.                         }*/
  311.                         System.out.println("------------------------------"+ Thread.currentThread().getName() + "----------------------" );
  312.                         synchronized (mLock) {
  313.                                 mCompletedThreadCount++; //已完成的线程数量加1
  314.                                 if(downListener != null){
  315.                                         if(mCompletedThreadCount == MAX_THREAD_NUM){ //已完成的线程数如果大于等于线程池的大小,则下载完成
  316.                                                 downListener.onDownloadCompleted(fileName);
  317.                                         }
  318.                                 }
  319.                         }
  320.         }
  321.     }
  322.     
  323.     private class SingleDowloadThread implements Runnable{
  324.             private String url = null;
  325.         private String fileName = null;
  326.         private long fileSize = 0; //下载的总长度
  327.         
  328.         public SingleDowloadThread(String url, String fileName, long fileSize) {
  329.                 this.url = url;
  330.                 this.fileName = fileName;
  331.                 this.fileSize = fileSize;
  332.                 }
  333.         
  334.                 @Override
  335.                 public void run() {
  336.                         HttpURLConnection httpConnection;
  337.                         try {
  338.                                 httpConnection = (HttpURLConnection) new URL(url).openConnection();
  339.                                 httpConnection.setRequestMethod("GET");
  340.                                 httpConnection.setRequestProperty("Accept", "image/gif, image/jpeg, image/pjpeg,*/*");
  341.                                 httpConnection.setRequestProperty("Accept-Language", "zh_CN");
  342.                                 httpConnection.setRequestProperty("Charset", "UTF-8");
  343.                                 httpConnection.setRequestProperty("User-Agent", "Mozilla/4.0(compatible; MSIE 7.0; Windows NT 5.2;)");
  344.                                 httpConnection.setRequestProperty("Connection", "Keep-Alive"); 
  345.                                 httpConnection.setConnectTimeout(15000); //15秒的连接超时
  346.                                 httpConnection.setReadTimeout(30000);//30秒的读写超时
  347.                                 int responseCode = httpConnection.getResponseCode();
  348.                                 if(responseCode == HttpURLConnection.HTTP_OK) {
  349.                                         InputStream inputStream = httpConnection.getInputStream();
  350.                                         FileOutputStream outputStream = new FileOutputStream(fileName);
  351.                                         byte[] buffer = new byte[1024];
  352.                                         int len = -1;
  353.                                         long readedBytes = 0;
  354.                                         long deltaReadBytes = 0; //在1秒的时间间隔之内，下载的字节数
  355.                                         //long mLastDownloadedTime = System.currentTimeMillis();
  356.                                         while( (len = inputStream.read(buffer, 0, buffer.length)) != -1) {
  357.                                                 outputStream.write(buffer, 0, len);
  358.                                                 readedBytes += len; 
  359.                                                 deltaReadBytes += len;
  360.                                                 
  361.                                                 long currentTime = System.currentTimeMillis();
  362.                                                 //System.out.println("currentTime - mLastDownloadedTime=" + (currentTime - mLastDownloadedTime) + "len=" + len);
  363.                                                 if((currentTime - mLastDownloadedTime ) /1000 > 1) {//时间差不到1秒不要去计算速度
  364.                                                         long speed = (long) (deltaReadBytes / ((currentTime - mLastDownloadedTime) / 1000.0) /1024);
  365.                                                         deltaReadBytes = 0; //计算了速度之后，需要对deltaReadBytes清零
  366.                                                         mLastDownloadedTime = currentTime; 
  367.                                                         if(downListener != null) {
  368.                                                                 downListener.onDownLoadSpeed(speed);
  369.                                                         }
  370.                                                 }
  371.                                                 //计算百分比
  372.                                                 int percent = (int) (readedBytes * 100 / fileSize);
  373.                                                 if(downListener != null) {
  374.                                                         if(percent - lastDownloadPercent >= 1) {
  375.                                                                 downListener.onCompleteRateChanged(percent);
  376.                                                         }
  377.                                                 }
  378.                                         }
  379.                                         if(downListener != null) {
  380.                                                 downListener.onDownloadCompleted(fileName);
  381.                                         }
  382.                                         inputStream.close();
  383.                                         outputStream.close();
  384.                                 }
  385.                         } catch (MalformedURLException e) {
  386.                                 e.printStackTrace();
  387.                         } catch (IOException e) {
  388.                                 e.printStackTrace();
  389.                         }
  390.                 }
  391.             
  392.     }
  393.     
  394.     private class UnKnownSizeSingleDowloadThread implements Runnable{
  395.             private String url = null;
  396.         private String fileName = null;
  397.         
  398.         public UnKnownSizeSingleDowloadThread(String url, String fileName) {
  399.                 this.url = url;
  400.                 this.fileName = fileName;
  401.                 }
  402.         
  403.                 @Override
  404.                 public void run() {
  405.                         HttpURLConnection httpConnection;
  406.                         try {
  407.                                 httpConnection = (HttpURLConnection) new URL(url).openConnection();
  408.                                 httpConnection.setRequestMethod("GET");
  409.                                 httpConnection.setRequestProperty("Accept", "image/gif, image/jpeg, image/pjpeg,*/*");
  410.                                 httpConnection.setRequestProperty("Accept-Language", "zh_CN");
  411.                                 httpConnection.setRequestProperty("Charset", "UTF-8");
  412.                                 httpConnection.setRequestProperty("User-Agent", "Mozilla/4.0(compatible; MSIE 7.0; Windows NT 5.2;)");
  413.                                 httpConnection.setRequestProperty("Connection", "Keep-Alive"); 
  414.                                 httpConnection.setConnectTimeout(15000); //15秒的连接超时
  415.                                 httpConnection.setReadTimeout(30000);//30秒的读写超时
  416.                                 int responseCode = httpConnection.getResponseCode();
  417.                                 if(responseCode == HttpURLConnection.HTTP_OK) {
  418.                                         InputStream inputStream = httpConnection.getInputStream();
  419.                                         FileOutputStream outputStream = new FileOutputStream(fileName);
  420.                                         byte[] buffer = new byte[1024];
  421.                                         int len = -1;
  422.                                         long deltaReadBytes = 0; //在1秒的时间间隔之内，下载的字节数
  423.                                         //long mLastDownloadedTime = System.currentTimeMillis();
  424.                                         while( (len = inputStream.read(buffer, 0, buffer.length)) != -1) {
  425.                                                 outputStream.write(buffer, 0, len);
  426.                                                 deltaReadBytes += len;
  427.                                                 
  428.                                                 long currentTime = System.currentTimeMillis();
  429.                                                 //System.out.println("currentTime - mLastDownloadedTime=" + (currentTime - mLastDownloadedTime) + "len=" + len);
  430.                                                 if((currentTime - mLastDownloadedTime ) /1000 > 1) {//时间差不到1秒不要去计算速度
  431.                                                         long speed = (long) (deltaReadBytes / ((currentTime - mLastDownloadedTime) / 1000.0) /1024);
  432.                                                         deltaReadBytes = 0; //计算了速度之后，需要对deltaReadBytes清零
  433.                                                         mLastDownloadedTime = currentTime; 
  434.                                                         if(downListener != null) {
  435.                                                                 downListener.onDownLoadSpeed(speed);
  436.                                                         }
  437.                                                 }
  438.                                                 //大小未知，无法计算百分比
  439.                                         }
  440.                                         if(downListener != null) {
  441.                                                 downListener.onDownloadCompleted(fileName);
  442.                                         }
  443.                                         inputStream.close();
  444.                                         outputStream.close();
  445.                                 }
  446.                         } catch (MalformedURLException e) {
  447.                                 e.printStackTrace();
  448.                         } catch (IOException e) {
  449.                                 e.printStackTrace();
  450.                         }
  451.                 }
  452.             
  453.     }
  454. }
复制代码


4： 下载程序测试主类。
  1. package com.eibit.javalearning;

  3. /**
  4. * Created by Administrator on 2016/4/16.
  5. */
  6. public class TestMultiDownload implements  DownListener{

  8.     public static void main(String[] args) {
  9.         String URL = "http://123.147.165.57:9999/dlsw.baidu.com/sw-search-sp/soft/ea/12585/mysql-5.6.24-win32.1432006610.zip";
  10.         String TARGET_FILE ="E:\\mysql-5.6.24-win32.1432006610.zip";
  11.         TestMultiDownload download = new TestMultiDownload();
  12.         ThreadPoolMultiDownLoadManager downLoadManager = new ThreadPoolMultiDownLoadManager(URL, TARGET_FILE, download);
  13.         downLoadManager.multiDownload();
  14.     }

  16.     @Override
  17.     public void onStartDownLoad() {
  18.         System.out.println("************ onStartDownLoad **************");
  19.     }

  21.     @Override
  22.     public void onCompleteRateChanged(int completeRate) {
  23.         System.out.println("************ onCompleteRateChanged completeRate= " + completeRate);
  24.     } 

  26.     @Override
  27.     public void onDownloadCompleted(String fileName) {
  28.         System.out.println("----------------------- onDownloadCompleted  fileName = " + fileName + "-------------------");
  29.     }

  31.     @Override
  32.     public void onStartMultiDownLoad(int numberThread) {
  33.         System.out.println("----------------------- onStartMultiDownLoad  numberThread = " + numberThread + "-------------------");
  34.     }

  36.     @Override
  37.     public void onBlockCompleted(int blockNum, long readBytes) {
  38.         System.out.println("----------------------- onBlockCompleted  BlockNum = " + blockNum + ",readBytes=" + readBytes + "-------------------");
  39.     }

  41.         @Override
  42.         public void onDownLoadSpeed(long speed) {
  43.                 System.out.println("----------------------- onDownLoadSpeed  speed=" + speed + " KB/s");
  44.         }
  45. }
复制代码

匆忙之间写下的程序，其中肯定有不足之处。欢迎大家不吝赐教！
java源代码详细注释 网络文件下载之分段下载（可扩展 断点续传）
sada09的专栏
08-15 3091
直接贴出代码 /*********************************************************************** * Module: DownloadConnection.java * Author: Administrator * Purpose: Defines the Class DownloadCon
java分段文件下载的实现与多线程下载最新版
02-02
项目中用到分段文件下载，也使用多线程下载，提高下载效率。 自己花了时间整合成一个项目，可直接执行Junit方法看效果。
java实现FTP多线程断点续传，上传下载！
weixin_34067980的博客
03-22 299
为什么80%的码农都做不了架构师？>>> ...
java大文件分段下载
最新发布
weixin_42456784的博客
06-11 343
这是一个实现文件分块下载功能的Spring Boot后端和前端示例。后端代码提供了支持HTTP Range请求的文件下载服务，能够处理完整下载和分片下载请求，返回206 Partial Content响应。前端界面包含下载按钮和进度条显示，采用Tailwind CSS进行样式设计。代码实现了跨域支持、文件存在性检查、范围请求解析、分片数据读取等功能，并通过响应头提供文件元数据。该方案适用于大文件下载场景，能够提升下载可靠性和用户体验。
java http 分段下载
weixin_33725515的博客
01-10 293
    http://www.iteye.com/topic/1136815   http://www.iteye.com/topic/1128336     http://blog.chinaunix.net/uid-11959329-id-3088466.html   http://bbs.csdn.net/topics/390053418
java线程池分段下载文件
sjgllllll的博客
12-24 1763
控制台输入下载链接： 一：实现基本的下载的功能
Java多线程分段下载技术实战解析
尽管没有具体的代码附带在此次解释中，但一个典型的Java多线程下载小例子可能包含以下部分： - 创建一个继承自Thread类或实现Runnable接口的类来表示下载任务。 - 在run方法中，实现文件段的下载逻辑。 - 创建多个...
JAVA多线程分段下载与断点续传实战代码详解
在Java编程中，实现多线程分段下载和断点续传功能是一项常见的需求，特别是在处理大文件下载时，能够提高用户体验和下载效率。下面将详细解释涉及的关键技术和代码实现。 1. 数据分段： 实现多线程分段下载首先...
JAVA代码实现多线程分段下载+断点续传
01-24
JAVA代码实现多线程分段下载+断点续传 原理很清楚，但是其中涉及到几个关键的问题： 1.需要请求的数据如何分段。 2.分段下载的数据如何组装成完整的数据文件。 3.断点的数据如何保存，再次下载如何继续上次保存的...
SpringBoot版本的多线程下载文件，分段下载文件
11-24
本篇将深入探讨如何利用SpringBoot实现多线程下载文件以及分段下载文件的技术。 首先，多线程下载文件是一种提高下载速度的方法，通过将大文件分成多个小部分，每个部分由一个单独的线程负责下载，从而充分利用多核...
httpclient多线程下载(分段下载)实践
03-26
总之，利用HTTPClient进行多线程分段下载是一种高效的方法，它结合了HTTP协议的特性与Java的多线程处理能力。通过合理的设计和实现，可以显著提升大文件下载的速度和用户体验。在实际编码中，开发者需要关注线程安全...
Java 利用多线程实现文件的分片下载
01-15
特别说明： Main方法是运行开始的方法，里面StopWatch是测速工具类，如果要想使用请导入相关maven坐标，不想使用直接删除即可。 内容概要： 这是随手写的一个利用线程池下载文件的小玩具，如果刚学完线程池不知道怎么使用的，可以拿来借鉴一下，互相学习。里面或许有些代码不太合理，但是作为练手项目还是可以的。 适用人群： 刚学完多线程和线程池，以及线程爱好者。 使用场景及目标： 大文件的快速下载，经测试在100M带宽的网络下，下载一个40M的文件，不超过两秒钟，当然还得根据自己电脑的配置来讲。 其他说明： 文件如果特别小，而自己网络又非常好的情况下，不建议使用线程池进行下载，因为线程任务的创建也会浪费一些时间和性能！因为写这个程序是为了更快的下载一些4K壁纸，所以传入的url只能是直链，当然 可以根据自己的能力进行改动。里面很多地方我都有注释说明，阅读起来不会很难。当然，希望道友可以指出代码的不足之处，让我们共同进步。毕竟分享是一个过程，能力的锻炼才是我们真正追求的结果！
java_分段上传_断点续传_超大附件上传spring-fileupload-plupload-mysql
01-08
一个可以运行的项目，关于大附件上传这块的关键技术，在mysql中创建 upload 数据库，导入sql文件，运行项目，修改 database.java 文件下的数据库密码，就实现了超大附件的分片上传，每个方法的功能都写着注解呢，个根据需要做断点续传功能！ 后端导了fileupload的jar包 前端用了plupload的js插件 没有加mybatis和spring更具需要自己加 如果满意可以请评论点赞
java 多线程分段下载
i_am_bad_man的博客
03-04 505
使用java 多线程下载，当前只是一个demo,还没进行对比测试，目前看速度确实要快一些实现和简单就是启用多个现成分段下载，最后再组合在一起解压打开后。
多线程分段下载——附java代码注解
辰小白
11-09 648
当时想着获取百度云盘真实下载地址，然后通过多线程分段下载来避开下载限速问题。记录一下线程分段下载 有哪位大神可以获取百度云真实下载地址，望留言 package test; import java.util.concurrent.CountDownLatch; public class Client { public static void main(String[] args) { ...
多线程下载文件！Demo
小小帅码农的博客
10-16 1446
package mutithreaddown; import java.io.InputStream; import java.io.RandomAccessFile; import java.net.HttpURLConnection; import java.net.URL; import java.util.concurrent.CountDownLatch; public class
java http 分段下载_【HTML】Http分段下载详解
weixin_35589827的博客
02-25 796
一.为什么需要Http分段下载在实际的业务开发中，大文件使用Http普通下载非常容易OOM(内存溢出)或是链接超时的错误，这种情况下应该就应该考虑使用Http的分段下载了。下面笔者为你介绍，Http协议如何实现分段下载。二.Http协议的结构介绍在正式开始之前，这里笔者先介绍一下Http的报文结构。Http的报文结构是由状态行、头部、空行、主体组成。在这里读者需要注意，GET请求和POST得到的报...
java分段文件下载的实现与多线程下载
德州仪器
01-30 1857
项目中用到分段文件下载，也使用多线程下载，提高下载效率。 自己花了时间整合成一个项目，可直接执行Junit方法看效果。 由于能力有限未免有不足的地方，请您指出。 下载地址:http://download.csdn.net/download/nk_tf/10232207
java网络编程之下载文件通过多线程分块下载(二)
YoYo_Newbie的专栏
11-06 2435
import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.RandomAccessFile; import java.net.HttpURLConnection; import java.net.URL; /** * 文件下载工具 by sam on 2015/11/5
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值